Improve image generation and auth responsiveness

services/account_service.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 
 import base64
 import json
+import time
 from concurrent.futures import ThreadPoolExecutor, as_completed
 from datetime import datetime, timedelta, timezone
 from threading import Condition, Lock
@@ -17,6 +18,7 @@ from utils.helper import anonymize_token
 
 
 EXPORT_TIMEZONE = timezone(timedelta(hours=8))
+IMAGE_ACCOUNT_REMOTE_CHECK_CACHE_SECONDS = 10 * 60
 
 
 def _clean_string(value: Any) -> str:
@@ -142,11 +144,23 @@ class AccountService:
         normalized["limits_progress"] = limits_progress if isinstance(limits_progress, list) else []
         normalized["default_model_slug"] = normalized.get("default_model_slug") or None
         normalized["restore_at"] = normalized.get("restore_at") or None
+        try:
+            normalized["image_checked_at"] = float(normalized.get("image_checked_at") or 0)
+        except (TypeError, ValueError):
+            normalized["image_checked_at"] = 0.0
         normalized["success"] = int(normalized.get("success") or 0)
         normalized["fail"] = int(normalized.get("fail") or 0)
         normalized["last_used_at"] = normalized.get("last_used_at")
         return normalized
 
+    @staticmethod
+    def _is_image_account_check_fresh(account: dict) -> bool:
+        try:
+            checked_at = float(account.get("image_checked_at") or 0)
+        except (TypeError, ValueError):
+            return False
+        return checked_at > 0 and time.time() - checked_at < IMAGE_ACCOUNT_REMOTE_CHECK_CACHE_SECONDS
+
     def list_tokens(self) -> list[str]:
         with self._lock:
             return list(self._accounts)
@@ -198,6 +212,10 @@ class AccountService:
         while True:
             access_token = self._acquire_next_candidate_token(excluded_tokens=attempted_tokens)
             attempted_tokens.add(access_token)
+            with self._lock:
+                cached_account = dict(self._accounts.get(access_token) or {})
+            if self._is_image_account_available(cached_account) and self._is_image_account_check_fresh(cached_account):
+                return access_token
             try:
                 account = self.fetch_remote_info(access_token, "get_available_access_token")
             except Exception:
@@ -427,6 +445,7 @@ class AccountService:
         except InvalidAccessTokenError:
             self.remove_invalid_token(access_token, event)
             raise
+        result["image_checked_at"] = time.time()
         return self.update_account(access_token, result)
 
     def refresh_accounts(self, access_tokens: list[str]) -> dict[str, Any]:
@@ -458,7 +477,7 @@ class AccountService:
                     errors.append({"token": anonymize_token(token), "error": str(exc)})
                     continue
                 if isinstance(result, dict):
-                    refreshed_items.append({"access_token": token, **result})
+                    refreshed_items.append({"access_token": token, **result, "image_checked_at": time.time()})
 
         with self._lock:
             changed = False

services/image_service.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import io
+import time
 import zipfile
 from pathlib import Path
 
@@ -15,6 +16,8 @@ from services.image_url_service import proxied_image_url
 
 THUMBNAIL_SIZE = (320, 320)
 IMAGE_CACHE_CONTROL = "public, max-age=2592000, immutable"
+IMAGE_MANAGER_CLEANUP_INTERVAL_SECONDS = 60 * 60
+_last_image_manager_cleanup_at = time.monotonic()
 
 
 def _image_cache_headers() -> dict[str, str]:
@@ -130,9 +133,19 @@ def cleanup_image_thumbnails() -> int:
     _cleanup_empty_dirs(thumbnails_root)
     return removed
 
-def list_images(base_url: str, start_date: str = "", end_date: str = "") -> dict[str, object]:
+
+def _cleanup_image_manager_if_due() -> None:
+    global _last_image_manager_cleanup_at
+    now = time.monotonic()
+    if now - _last_image_manager_cleanup_at < IMAGE_MANAGER_CLEANUP_INTERVAL_SECONDS:
+        return
+    _last_image_manager_cleanup_at = now
     config.cleanup_old_images()
     cleanup_image_thumbnails()
+
+
+def list_images(base_url: str, start_date: str = "", end_date: str = "") -> dict[str, object]:
+    _cleanup_image_manager_if_due()
     all_tags = load_tags()
     items = [
         {

services/image_storage_service.py

@@ -3,6 +3,7 @@ from __future__ import annotations
 import hashlib
 import io
 import json
+import time
 from dataclasses import dataclass
 from pathlib import Path
 from threading import Lock
@@ -19,6 +20,7 @@ from services.time_utils import china_date_from_timestamp_string, china_from_tim
 IMAGE_INDEX_FILE = DATA_DIR / "image_index.json"
 IMAGE_INDEX_LOCK = Lock()
 IMAGE_EXTENSIONS = {".png", ".jpg", ".jpeg", ".webp"}
+IMAGE_SAVE_CLEANUP_INTERVAL_SECONDS = 6 * 60 * 60
 
 
 class ImageStorageError(RuntimeError):
@@ -168,6 +170,7 @@ class ImageStorageService:
     def __init__(self, index_file: Path = IMAGE_INDEX_FILE):
         self.index_file = index_file
         self._index_lock = IMAGE_INDEX_LOCK
+        self._last_cleanup_at = time.monotonic()
 
     def settings(self) -> dict[str, object]:
         return config.get_image_storage_settings()
@@ -203,8 +206,19 @@ class ImageStorageService:
         relative_dir = Path(now.strftime("%Y"), now.strftime("%m"), now.strftime("%d"))
         return f"{relative_dir.as_posix()}/{filename}"
 
+    def _cleanup_old_images_if_due(self) -> int:
+        now = time.monotonic()
+        if now - self._last_cleanup_at < IMAGE_SAVE_CLEANUP_INTERVAL_SECONDS:
+            return 0
+        self._last_cleanup_at = now
+        try:
+            return int(config.cleanup_old_images() or 0)
+        except Exception as exc:
+            print(f"[image-storage] cleanup skipped: {exc}")
+            return 0
+
     def save(self, image_data: bytes, base_url: str | None = None) -> StoredImage:
-        config.cleanup_old_images()
+        self._cleanup_old_images_if_due()
         rel = self.make_relative_path(image_data)
         mode = self.mode()
         if mode not in {"local", "webdav", "both"}:

services/image_task_service.py

@@ -20,6 +20,7 @@ TASK_STATUS_SUCCESS = "success"
 TASK_STATUS_ERROR = "error"
 TERMINAL_STATUSES = {TASK_STATUS_SUCCESS, TASK_STATUS_ERROR}
 UNFINISHED_STATUSES = {TASK_STATUS_QUEUED, TASK_STATUS_RUNNING}
+TASK_CLEANUP_INTERVAL_SECONDS = 60 * 60
 
 
 def _now_iso() -> str:
@@ -95,6 +96,7 @@ class ImageTaskService:
         self.retention_days_getter = retention_days_getter or (lambda: config.image_retention_days)
         self._lock = threading.RLock()
         self._tasks: dict[str, dict[str, Any]] = {}
+        self._last_cleanup_at = time.monotonic()
         self.path.parent.mkdir(parents=True, exist_ok=True)
         with self._lock:
             self._tasks = self._load_locked()
@@ -167,7 +169,7 @@ class ImageTaskService:
         owner = _owner_id(identity)
         requested_ids = [_clean(task_id) for task_id in task_ids if _clean(task_id)]
         with self._lock:
-            if self._cleanup_locked():
+            if self._cleanup_if_due_locked():
                 self._save_locked()
             items = []
             missing_ids = []
@@ -205,7 +207,7 @@ class ImageTaskService:
         now = _now_iso()
         should_start = False
         with self._lock:
-            cleaned = self._cleanup_locked()
+            cleaned = self._cleanup_if_due_locked()
             task = self._tasks.get(key)
             if task is not None:
                 if cleaned:
@@ -502,5 +504,12 @@ class ImageTaskService:
             self._tasks.pop(key, None)
         return bool(removed_keys)
 
+    def _cleanup_if_due_locked(self) -> bool:
+        now = time.monotonic()
+        if now - self._last_cleanup_at < TASK_CLEANUP_INTERVAL_SECONDS:
+            return False
+        self._last_cleanup_at = now
+        return self._cleanup_locked()
+
 
 image_task_service = ImageTaskService(DATA_DIR / "image_tasks.json")

test/test_account_image_capabilities.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 
 import os
 import tempfile
+import time
 import unittest
 from pathlib import Path
 
@@ -71,6 +72,60 @@ class AccountCapabilityTests(unittest.TestCase):
             self.assertTrue(updated["image_quota_unknown"])
 
 
+    def test_get_available_access_token_uses_fresh_cached_account_info(self) -> None:
+        with tempfile.TemporaryDirectory() as tmp_dir:
+            service = AccountService(JSONStorageBackend(Path(tmp_dir) / "accounts.json"))
+            service.add_accounts(["token-1"])
+            service.update_account(
+                "token-1",
+                {
+                    "status": "姝ｅ父",
+                    "quota": 5,
+                    "image_checked_at": time.time(),
+                },
+            )
+
+            def fail_fetch_remote_info(_access_token: str, _event: str = "fetch_remote_info") -> dict:
+                self.fail("fresh cached account should not be remotely refreshed before image generation")
+
+            service.fetch_remote_info = fail_fetch_remote_info  # type: ignore[method-assign]
+
+            self.assertEqual(service.get_available_access_token(), "token-1")
+            service.release_image_slot("token-1")
+
+    def test_get_available_access_token_refreshes_stale_account_info(self) -> None:
+        with tempfile.TemporaryDirectory() as tmp_dir:
+            service = AccountService(JSONStorageBackend(Path(tmp_dir) / "accounts.json"))
+            service.add_accounts(["token-1"])
+            service.update_account(
+                "token-1",
+                {
+                    "status": "姝ｅ父",
+                    "quota": 5,
+                    "image_checked_at": 1,
+                },
+            )
+            calls = 0
+
+            def fetch_remote_info(access_token: str, _event: str = "fetch_remote_info") -> dict:
+                nonlocal calls
+                calls += 1
+                return service.update_account(
+                    access_token,
+                    {
+                        "status": "姝ｅ父",
+                        "quota": 5,
+                        "image_checked_at": time.time(),
+                    },
+                ) or {}
+
+            service.fetch_remote_info = fetch_remote_info  # type: ignore[method-assign]
+
+            self.assertEqual(service.get_available_access_token(), "token-1")
+            service.release_image_slot("token-1")
+            self.assertEqual(calls, 1)
+
+
 class TokenLogTests(unittest.TestCase):
     def test_anonymize_token_hides_raw_value(self) -> None:
         token = "super-secret-token"

web/src/app/image/components/image-results.tsx

@@ -6,7 +6,7 @@ import { Clock3, Download, LoaderCircle, RotateCcw, Sparkles, Trash2 } from "luc
 import { Button } from "@/components/ui/button";
 import { downloadImageSrc, normalizeImageUrl } from "@/lib/image-url";
 import { cn } from "@/lib/utils";
-import type { ImageConversation, ImageTurnStatus, StoredImage, StoredReferenceImage } from "@/store/image-conversations";
+import type { ImageConversation, ImageConversationMode, ImageTurnStatus, StoredImage, StoredReferenceImage } from "@/store/image-conversations";
 
 export type ImageLightboxItem = {
   id: string;
@@ -307,6 +307,7 @@ export function ImageResults({
                         <GeneratingImagePlaceholder
                           key={image.id}
                           imageIndex={index}
+                          mode={turn.mode}
                           size={turn.size}
                           isQueued={!image.startedAt}
                           elapsedSeconds={getElapsedSeconds(image.startedAt || turn.createdAt, now)}
@@ -351,16 +352,18 @@ export function ImageResults({
 
 function GeneratingImagePlaceholder({
   imageIndex,
+  mode,
   size,
   isQueued,
   elapsedSeconds,
 }: {
   imageIndex: number;
+  mode: ImageConversationMode;
   size: string;
   isQueued: boolean;
   elapsedSeconds: number;
 }) {
-  const stage = isQueued ? "等待进入生成队列" : getGenerationStage(elapsedSeconds, imageIndex);
+  const stage = isQueued ? "等待进入生成队列" : getGenerationStage(elapsedSeconds, imageIndex, mode === "edit");
   const displayStage = stage;
   const elapsedLabel = `${isQueued ? "排队中" : "生成中"} ${formatElapsedTime(elapsedSeconds)}`;
   return (
@@ -409,8 +412,11 @@ function getElapsedSeconds(value: string, now: number) {
   return Math.max(0, Math.floor((now - started) / 1000));
 }
 
-function getGenerationStage(elapsedSeconds: number, imageIndex: number) {
-  const stageElapsedSeconds = elapsedSeconds + getStageHintOffsetSeconds(imageIndex);
+function getGenerationStage(elapsedSeconds: number, imageIndex: number, isEditMode = false) {
+  if (isEditMode && elapsedSeconds < 5) {
+    return "正在分析参考图";
+  }
+  const stageElapsedSeconds = (isEditMode ? Math.max(0, elapsedSeconds - 5) : elapsedSeconds) + getStageHintOffsetSeconds(imageIndex);
   return GENERATION_STAGES.find((stage) => stageElapsedSeconds < stage.until)?.label || GENERATION_STAGES[GENERATION_STAGES.length - 1].label;
 }
 

web/src/app/image/page.tsx

@@ -178,7 +178,7 @@ async function buildReferenceImageFromStoredImage(image: StoredImage, fileName:
 }
 
 function taskDataToStoredImage(image: StoredImage, task: ImageTask): StoredImage {
-  const startedAt = task.started_at || (task.status === "running" ? image.startedAt : undefined);
+  const startedAt = task.started_at || image.startedAt;
   if (task.status === "success") {
     const first = task.data?.[0];
     if (!first?.b64_json && !first?.url) {
@@ -1040,6 +1040,7 @@ function ImagePageContent({ session }: { session: StoredAuthSession }) {
       };
 
       try {
+        const activeStartedAt = new Date().toISOString();
         await updateConversation(conversationId, (current) => {
           const conversation = current ?? snapshot;
           return {
@@ -1049,10 +1050,12 @@ function ImagePageContent({ session }: { session: StoredAuthSession }) {
               turn.id === activeTurn.id
                 ? {
                     ...turn,
-                    status: "queued",
+                    status: "generating",
                     error: undefined,
                     images: turn.images.map((image) =>
-                      image.status === "loading" ? { ...image, taskId: image.taskId || image.id } : image,
+                      image.status === "loading"
+                        ? { ...image, taskId: image.taskId || image.id, startedAt: image.startedAt || activeStartedAt }
+                        : image,
                     ),
                   }
                 : turn,
@@ -1078,6 +1081,7 @@ function ImagePageContent({ session }: { session: StoredAuthSession }) {
         );
         await applyTasks(submitted);
 
+        const taskPollStartedAt = Date.now();
         while (true) {
           const latestConversation = conversationsRef.current.find((conversation) => conversation.id === conversationId);
           const latestTurn = latestConversation?.turns.find((turn) => turn.id === activeTurn.id);
@@ -1089,7 +1093,8 @@ function ImagePageContent({ session }: { session: StoredAuthSession }) {
             break;
           }
 
-          await sleep(2000);
+          const taskPollElapsed = Date.now() - taskPollStartedAt;
+          await sleep(taskPollElapsed < 20_000 ? 800 : 2000);
           const taskList = await fetchImageTasks(loadingTaskIds);
           if (taskList.items.length > 0) {
             await applyTasks(taskList.items);
@@ -1382,7 +1387,6 @@ function ImagePageContent({ session }: { session: StoredAuthSession }) {
         name: nextProfile.name || normalizedName,
         wechatOpenid: nextProfile.wechat_openid || session.wechatOpenid,
       });
-      window.dispatchEvent(new Event("chatgpt2api:auth-session-updated"));
       setIsProfileOpen(false);
       toast.success("昵称已保存");
     } catch (error) {

web/src/components/top-nav.tsx

@@ -68,9 +68,13 @@ export function TopNav() {
     };
   }, [pathname]);
 
-  const handleLogout = async () => {
-    await clearStoredAuthSession();
+  const handleLogout = () => {
+    const clearPromise = clearStoredAuthSession();
+    setSession(null);
     router.replace("/login");
+    void clearPromise.catch((error) => {
+      console.warn("clear auth session failed", error);
+    });
   };
 
   if (pathname === "/login" || session === undefined || !session) {
@@ -104,7 +108,7 @@ export function TopNav() {
           <button
             type="button"
             className="ml-auto shrink-0 py-1 text-xs text-stone-400 transition hover:text-stone-700 sm:hidden"
-            onClick={() => void handleLogout()}
+            onClick={handleLogout}
           >
             退出
           </button>
@@ -140,7 +144,7 @@ export function TopNav() {
           <button
             type="button"
             className="py-1 text-xs text-stone-400 transition hover:text-stone-700 sm:text-sm"
-            onClick={() => void handleLogout()}
+            onClick={handleLogout}
           >
             退出
           </button>

web/src/store/auth.ts

@@ -20,6 +20,15 @@ const authStorage = localforage.createInstance({
   storeName: "auth",
 });
 
+let authSessionClearedInMemory = false;
+
+function emitAuthSessionUpdated() {
+  if (typeof window === "undefined") {
+    return;
+  }
+  window.dispatchEvent(new Event("chatgpt2api:auth-session-updated"));
+}
+
 function normalizeSession(value: unknown, fallbackKey = ""): StoredAuthSession | null {
   if (!value || typeof value !== "object") {
     return null;
@@ -49,6 +58,9 @@ export async function getStoredAuthKey() {
   if (typeof window === "undefined") {
     return "";
   }
+  if (authSessionClearedInMemory) {
+    return "";
+  }
   const value = await authStorage.getItem<string>(AUTH_KEY_STORAGE_KEY);
   return String(value || "").trim();
 }
@@ -57,6 +69,9 @@ export async function getStoredAuthSession() {
   if (typeof window === "undefined") {
     return null;
   }
+  if (authSessionClearedInMemory) {
+    return null;
+  }
 
   const [storedKey, storedSession] = await Promise.all([
     authStorage.getItem<string>(AUTH_KEY_STORAGE_KEY),
@@ -84,10 +99,12 @@ export async function setStoredAuthSession(session: StoredAuthSession) {
     return;
   }
 
+  authSessionClearedInMemory = false;
   await Promise.all([
     authStorage.setItem(AUTH_KEY_STORAGE_KEY, normalizedSession.key),
     authStorage.setItem(AUTH_SESSION_STORAGE_KEY, normalizedSession),
   ]);
+  emitAuthSessionUpdated();
 }
 
 export async function setStoredAuthKey(authKey: string) {
@@ -96,13 +113,17 @@ export async function setStoredAuthKey(authKey: string) {
     await clearStoredAuthSession();
     return;
   }
+  authSessionClearedInMemory = false;
   await authStorage.setItem(AUTH_KEY_STORAGE_KEY, normalizedAuthKey);
+  emitAuthSessionUpdated();
 }
 
 export async function clearStoredAuthSession() {
   if (typeof window === "undefined") {
     return;
   }
+  authSessionClearedInMemory = true;
+  emitAuthSessionUpdated();
   await Promise.all([
     authStorage.removeItem(AUTH_KEY_STORAGE_KEY),
     authStorage.removeItem(AUTH_SESSION_STORAGE_KEY),