fix: align account rate-limit testing stats

Author: james-6-23

admin/test_connection.go

@@ -74,6 +74,11 @@ func (h *Handler) TestConnection(c *gin.Context) {
 	// 发送 test_start
 	sendTestEvent(c, testEvent{Type: "test_start", Model: testModel})
 
+	if resetAt, ok := activeLocalRateLimitReset(account); ok && !forceConnectionTest(c) {
+		sendTestEvent(c, testEvent{Type: "error", Error: formatLocalRateLimitTestError(resetAt)})
+		return
+	}
+
 	// 构建最小测试请求体（参考 sub2api createOpenAITestPayload）
 	payload := buildTestPayload(testModel)
 
@@ -100,6 +105,10 @@ func (h *Handler) TestConnection(c *gin.Context) {
 	}
 
 	usageState := proxy.SyncCodexUsageState(h.store, account, resp)
+	if msg, limited := formatUsageLimitedTestError(usageState); limited {
+		sendTestEvent(c, testEvent{Type: "error", Error: msg})
+		return
+	}
 
 	// 解析 SSE 流
 	hasContent := false
@@ -220,6 +229,58 @@ func buildTestPayload(model string) []byte {
 	return payload
 }
 
+func forceConnectionTest(c *gin.Context) bool {
+	if c == nil {
+		return false
+	}
+	switch strings.ToLower(strings.TrimSpace(c.Query("force"))) {
+	case "1", "true", "yes":
+		return true
+	default:
+		return false
+	}
+}
+
+func activeLocalRateLimitReset(account *auth.Account) (time.Time, bool) {
+	if account == nil {
+		return time.Time{}, false
+	}
+	now := time.Now()
+	if account.IsPremium5hRateLimited() {
+		_, resetAt, ok := account.GetUsageSnapshot5h()
+		if ok && resetAt.After(now) {
+			return resetAt, true
+		}
+	}
+	reason, until := account.GetCooldownSnapshot()
+	if reason == "rate_limited" && until.After(now) {
+		return until, true
+	}
+	return time.Time{}, false
+}
+
+func formatLocalRateLimitTestError(resetAt time.Time) string {
+	remaining := time.Until(resetAt).Round(time.Second)
+	if remaining < 0 {
+		remaining = 0
+	}
+	return fmt.Sprintf("账号当前处于本地限流状态，预计 %s 后恢复；本次未发送上游探针。需要强制探针时可添加 force=1。", remaining)
+}
+
+func formatUsageLimitedTestError(state proxy.CodexUsageSyncResult) (string, bool) {
+	if state.Premium5hRateLimited {
+		remaining := time.Until(state.Reset5hAt).Round(time.Second)
+		if remaining < 0 {
+			remaining = 0
+		}
+		return fmt.Sprintf("上游探针返回 200，但 Codex 5h 用量头已达 %.0f%%，账号已保持限流状态，预计 %s 后恢复。", state.UsagePct5h, remaining), true
+	}
+	if state.HasUsage7d && state.UsagePct7d >= 100 {
+		return fmt.Sprintf("上游探针返回 200，但 Codex 7d 用量头已达 %.0f%%，账号已保持用量耗尽状态。", state.UsagePct7d), true
+	}
+	return "", false
+}
+
 // sendTestEvent 发送 SSE 事件
 func sendTestEvent(c *gin.Context, event testEvent) {
 	data, err := json.Marshal(event)
@@ -462,6 +523,11 @@ func (h *Handler) BatchTest(c *gin.Context) {
 			sem <- struct{}{}
 			defer func() { <-sem }()
 
+			if _, ok := activeLocalRateLimitReset(acc); ok {
+				atomic.AddInt64(&rateLimitCount, 1)
+				return
+			}
+
 			resp, err := proxy.ExecuteRequest(context.Background(), acc, payload, "", h.store.ResolveProxyForAccount(acc), "", nil, nil)
 			if err != nil {
 				h.store.MarkError(acc, "批量测试请求失败: "+err.Error())
@@ -474,10 +540,12 @@ func (h *Handler) BatchTest(c *gin.Context) {
 			switch resp.StatusCode {
 			case http.StatusOK:
 				usageState := proxy.SyncCodexUsageState(h.store, acc, resp)
-				// 测试成功即重置冷却状态，用量限制由调度器自行判断
-				if !usageState.Premium5hRateLimited && (!usageState.HasUsage7d || usageState.UsagePct7d < 100) {
-					h.store.ClearCooldown(acc)
+				if _, limited := formatUsageLimitedTestError(usageState); limited {
+					atomic.AddInt64(&rateLimitCount, 1)
+					return
 				}
+				// 测试成功即重置冷却状态，用量限制由调度器自行判断
+				h.store.ClearCooldown(acc)
 				atomic.AddInt64(&successCount, 1)
 			case http.StatusUnauthorized:
 				proxy.SyncCodexUsageState(h.store, acc, resp)

admin/test_connection_test.go

@@ -3,7 +3,10 @@ package admin
 import (
 	"strings"
 	"testing"
+	"time"
 
+	"github.com/codex2api/auth"
+	"github.com/codex2api/proxy"
 	"github.com/tidwall/gjson"
 )
 
@@ -29,6 +32,41 @@ func TestBuildTestPayloadUsesSelectedModel(t *testing.T) {
 	}
 }
 
+func TestActiveLocalRateLimitResetDetectsPremium5h(t *testing.T) {
+	resetAt := time.Now().Add(30 * time.Minute)
+	acc := &auth.Account{
+		PlanType:            "plus",
+		UsagePercent5h:      100,
+		UsagePercent5hValid: true,
+		Reset5hAt:           resetAt,
+	}
+
+	got, ok := activeLocalRateLimitReset(acc)
+	if !ok {
+		t.Fatal("activeLocalRateLimitReset() ok = false, want true")
+	}
+	if !got.Equal(resetAt) {
+		t.Fatalf("resetAt = %v, want %v", got, resetAt)
+	}
+}
+
+func TestFormatUsageLimitedTestErrorReportsSuccessfulProbeAsLimited(t *testing.T) {
+	msg, limited := formatUsageLimitedTestError(proxy.CodexUsageSyncResult{
+		Premium5hRateLimited: true,
+		UsagePct5h:           100,
+		Reset5hAt:            time.Now().Add(time.Hour),
+	})
+
+	if !limited {
+		t.Fatal("limited = false, want true")
+	}
+	for _, want := range []string{"返回 200", "5h 用量头", "限流状态"} {
+		if !strings.Contains(msg, want) {
+			t.Fatalf("message %q does not contain %q", msg, want)
+		}
+	}
+}
+
 func TestExtractCompletedOutputText(t *testing.T) {
 	event := []byte(`{
 		"type":"response.completed",

frontend/src/components/StatusBadge.tsx

@@ -3,6 +3,7 @@ import { useTranslation } from 'react-i18next'
 
 interface StatusBadgeProps {
   status?: string | null
+  detail?: string | null
 }
 
 const statusConfig: Record<string, { variant: 'default' | 'secondary' | 'destructive' | 'outline'; dotColor: string }> = {
@@ -17,7 +18,7 @@ const statusConfig: Record<string, { variant: 'default' | 'secondary' | 'destruc
   paused: { variant: 'outline', dotColor: 'bg-blue-500' },
 }
 
-export default function StatusBadge({ status }: StatusBadgeProps) {
+export default function StatusBadge({ status, detail }: StatusBadgeProps) {
   const { t } = useTranslation()
   const key = status ?? 'unknown'
   const config = statusConfig[key] ?? { variant: 'outline' as const, dotColor: 'bg-gray-400' }
@@ -26,6 +27,12 @@ export default function StatusBadge({ status }: StatusBadgeProps) {
     <Badge variant={config.variant} className="gap-1.5 text-[13px]">
       <span className={`size-1.5 rounded-full ${config.dotColor}`} />
       {t(`status.${key}`, { defaultValue: t('status.unknown', { defaultValue: key }) })}
+      {detail && (
+        <>
+          <span className="h-3 w-px bg-current/20" />
+          <span className="text-[11px] font-bold leading-none">{detail}</span>
+        </>
+      )}
     </Badge>
   )
 }

frontend/src/pages/Accounts.tsx

@@ -160,9 +160,8 @@ export default function Accounts() {
 
   const totalAccounts = accounts.length
   const normalAccounts = accounts.filter((account) => account.status === 'active' || account.status === 'ready').length
-  const rateLimitedAccountRows = accounts.filter(isRateLimitedAccount)
-  const rateLimitedWindowStats = getRateLimitedWindowStats(rateLimitedAccountRows)
-  const rateLimitedAccounts = rateLimitedAccountRows.length
+  const rateLimitedWindowStats = getRateLimitedWindowStats(accounts)
+  const rateLimitedAccounts = rateLimitedWindowStats.total
   const rateLimited5hAccounts = rateLimitedWindowStats.fiveHour
   const rateLimited7dAccounts = rateLimitedWindowStats.sevenDay
   const bannedAccounts = accounts.filter((account) => account.status === 'unauthorized').length
@@ -1379,7 +1378,7 @@ export default function Accounts() {
                         <TableCell>
                           <div className="space-y-1.5">
                             <div className="flex min-h-6 items-center gap-2 whitespace-nowrap">
-                              <StatusBadge status={account.status} />
+                              <StatusBadge status={account.status} detail={getAccountRateLimitWindow(account) ?? undefined} />
                               <AccountStatusCountdown account={account} />
                             </div>
                             {account.status === 'error' && account.error_message && (
@@ -2373,59 +2372,74 @@ function isUsageWindowExhausted(value?: number | null): boolean {
   return typeof value === 'number' && Number.isFinite(value) && value >= 100
 }
 
+function isActiveUsageWindowExhausted(value?: number | null, resetAt?: string): boolean {
+  return isUsageWindowExhausted(value) && (!resetAt || isFutureTime(resetAt))
+}
+
 function isPremiumUsagePlan(planType?: string): boolean {
   return ['plus', 'pro', 'team', 'teamplus'].includes(normalizePlanType(planType))
 }
 
+type RateLimitWindow = '5h' | '7d'
+
 function isRateLimitedAccount(account: AccountRow): boolean {
+  return getAccountRateLimitWindow(account) !== null
+}
+
+function getAccountRateLimitWindow(account: AccountRow): RateLimitWindow | null {
   const status = (account.status || '').toLowerCase()
   const reason = (account.cooldown_reason || '').toLowerCase()
-
-  return status === 'rate_limited' ||
+  const explicitlyRateLimited = status === 'rate_limited' ||
     status === 'usage_exhausted' ||
     status === 'rate_limited_5h' ||
     status === 'rate_limited_7d' ||
+    reason === 'rate_limited' ||
     reason === 'rate_limited_5h' ||
     reason === 'rate_limited_7d'
-}
-
-function getAccountRateLimitWindow(account: AccountRow): '5h' | '7d' {
-  const status = (account.status || '').toLowerCase()
-  const reason = (account.cooldown_reason || '').toLowerCase()
+  const has7dLimit = isActiveUsageWindowExhausted(account.usage_percent_7d, account.reset_7d_at)
+  const has5hLimit = isPremiumUsagePlan(account.plan_type) &&
+    isActiveUsageWindowExhausted(account.usage_percent_5h, account.reset_5h_at)
 
+  // Prefer the longer 7d window when both windows are exhausted so each account
+  // belongs to exactly one bucket and 5h + 7d stays equal to total limited.
   if (
     status === 'usage_exhausted' ||
     status === 'rate_limited_7d' ||
     reason === 'rate_limited_7d' ||
-    (isUsageWindowExhausted(account.usage_percent_7d) && (!account.reset_7d_at || isFutureTime(account.reset_7d_at)))
+    has7dLimit
   ) {
     return '7d'
   }
 
   if (
     status === 'rate_limited_5h' ||
     reason === 'rate_limited_5h' ||
-    (
-      isPremiumUsagePlan(account.plan_type) &&
-      isUsageWindowExhausted(account.usage_percent_5h) &&
-      (!account.reset_5h_at || isFutureTime(account.reset_5h_at))
-    )
+    has5hLimit
   ) {
     return '5h'
   }
 
-  return '5h'
+  return explicitlyRateLimited ? '5h' : null
 }
 
-function getRateLimitedWindowStats(accounts: AccountRow[]): { fiveHour: number; sevenDay: number } {
-  return accounts.reduce((stats, account) => {
-    if (getAccountRateLimitWindow(account) === '7d') {
+function getRateLimitedWindowStats(accounts: AccountRow[]): { total: number; fiveHour: number; sevenDay: number } {
+  const stats = accounts.reduce((stats, account) => {
+    const window = getAccountRateLimitWindow(account)
+    if (!window) {
+      return stats
+    }
+    if (window === '7d') {
       stats.sevenDay += 1
     } else {
       stats.fiveHour += 1
     }
     return stats
   }, { fiveHour: 0, sevenDay: 0 })
+
+  return {
+    ...stats,
+    total: stats.fiveHour + stats.sevenDay,
+  }
 }
 
 function isSubscriptionPlan(planType?: string): boolean {
@@ -2645,12 +2659,12 @@ function CompactStat({
           {chipLabel ?? label}
         </div>
         {details && details.length > 0 && (
-          <div className="flex flex-col items-end gap-0.5 text-[11px] font-semibold leading-4 text-muted-foreground">
+          <div className="flex w-[4.75rem] flex-col gap-0.5 text-[11px] font-semibold leading-4 text-muted-foreground">
             {details.map((item) => (
-              <div key={item.label} className="tabular-nums">
-                <span>{item.label}</span>
-                <span className="mx-0.5">：</span>
-                <span className="text-foreground">{item.value}</span>
+              <div key={item.label} className="grid grid-cols-[2ch_auto_1fr] items-center gap-x-1 tabular-nums">
+                <span className="justify-self-start">{item.label}</span>
+                <span className="justify-self-center">：</span>
+                <span className="justify-self-end text-foreground">{item.value}</span>
               </div>
             ))}
           </div>