Upload 8 files

core/account.py

@@ -0,0 +1,514 @@
+"""账户管理模块
+
+负责账户配置、多账户协调和会话缓存管理
+"""
+import asyncio
+import json
+import logging
+import os
+import time
+from dataclasses import dataclass
+from datetime import datetime, timedelta, timezone
+from typing import Dict, List, Optional, TYPE_CHECKING
+
+from fastapi import HTTPException
+
+if TYPE_CHECKING:
+    from core.jwt import JWTManager
+
+logger = logging.getLogger(__name__)
+
+# 配置文件路径
+ACCOUNTS_FILE = "accounts.json"
+
+
+@dataclass
+class AccountConfig:
+    """单个账户配置"""
+    account_id: str
+    secure_c_ses: str
+    host_c_oses: Optional[str]
+    csesidx: str
+    config_id: str
+    expires_at: Optional[str] = None  # 账户过期时间 (格式: "2025-12-23 10:59:21")
+    disabled: bool = False  # 手动禁用状态
+
+    def get_remaining_hours(self) -> Optional[float]:
+        """计算账户剩余小时数"""
+        if not self.expires_at:
+            return None
+        try:
+            # 解析过期时间（假设为北京时间）
+            beijing_tz = timezone(timedelta(hours=8))
+            expire_time = datetime.strptime(self.expires_at, "%Y-%m-%d %H:%M:%S")
+            expire_time = expire_time.replace(tzinfo=beijing_tz)
+
+            # 当前时间（北京时间）
+            now = datetime.now(beijing_tz)
+
+            # 计算剩余时间
+            remaining = (expire_time - now).total_seconds() / 3600
+            return remaining
+        except Exception:
+            return None
+
+    def is_expired(self) -> bool:
+        """检查账户是否已过期"""
+        remaining = self.get_remaining_hours()
+        if remaining is None:
+            return False  # 未设置过期时间，默认不过期
+        return remaining <= 0
+
+
+def format_account_expiration(remaining_hours: Optional[float]) -> tuple:
+    """
+    格式化账户过期时间显示（基于12小时过期周期）
+
+    Args:
+        remaining_hours: 剩余小时数（None表示未设置过期时间）
+
+    Returns:
+        (status, status_color, expire_display) 元组
+    """
+    if remaining_hours is None:
+        # 未设置过期时间时显示为"未设置"
+        return ("未设置", "#9e9e9e", "未设置")
+    elif remaining_hours <= 0:
+        return ("已过期", "#f44336", "已过期")
+    elif remaining_hours < 3:  # 少于3小时
+        return ("即将过期", "#ff9800", f"{remaining_hours:.1f} 小时")
+    else:  # 3小时及以上，统一显示小时
+        return ("正常", "#4caf50", f"{remaining_hours:.1f} 小时")
+
+
+class AccountManager:
+    """单个账户管理器"""
+    def __init__(self, config: AccountConfig, http_client, user_agent: str, account_failure_threshold: int, rate_limit_cooldown_seconds: int):
+        self.config = config
+        self.http_client = http_client
+        self.user_agent = user_agent
+        self.account_failure_threshold = account_failure_threshold
+        self.rate_limit_cooldown_seconds = rate_limit_cooldown_seconds
+        self.jwt_manager: Optional['JWTManager'] = None  # 延迟初始化
+        self.is_available = True
+        self.last_error_time = 0.0
+        self.last_429_time = 0.0  # 429错误专属时间戳
+        self.error_count = 0
+        self.conversation_count = 0  # 累计对话次数
+
+    async def get_jwt(self, request_id: str = "") -> str:
+        """获取 JWT token (带错误处理)"""
+        # 检查账户是否过期
+        if self.config.is_expired():
+            self.is_available = False
+            logger.warning(f"[ACCOUNT] [{self.config.account_id}] 账户已过期，已自动禁用")
+            raise HTTPException(403, f"Account {self.config.account_id} has expired")
+
+        try:
+            if self.jwt_manager is None:
+                # 延迟初始化 JWTManager (避免循环依赖)
+                from core.jwt import JWTManager
+                self.jwt_manager = JWTManager(self.config, self.http_client, self.user_agent)
+            jwt = await self.jwt_manager.get(request_id)
+            self.is_available = True
+            self.error_count = 0
+            return jwt
+        except Exception as e:
+            self.last_error_time = time.time()
+            self.error_count += 1
+            # 使用配置的失败阈值
+            if self.error_count >= self.account_failure_threshold:
+                self.is_available = False
+                logger.error(f"[ACCOUNT] [{self.config.account_id}] JWT获取连续失败{self.error_count}次，账户已永久禁用")
+            else:
+                # 安全：只记录异常类型，不记录详细信息
+                logger.warning(f"[ACCOUNT] [{self.config.account_id}] JWT获取失败({self.error_count}/{self.account_failure_threshold}): {type(e).__name__}")
+            raise
+
+    def should_retry(self) -> bool:
+        """检查账户是否可重试（429错误10分钟后恢复���普通错误永久禁用）"""
+        if self.is_available:
+            return True
+
+        current_time = time.time()
+
+        # 检查429冷却期（10分钟后自动恢复）
+        if self.last_429_time > 0:
+            if current_time - self.last_429_time > self.rate_limit_cooldown_seconds:
+                return True  # 冷却期已过，可以重试
+            return False  # 仍在冷却期
+
+        # 普通错误永久禁用
+        return False
+
+    def get_cooldown_info(self) -> tuple[int, str | None]:
+        """
+        获取账户冷却信息
+
+        Returns:
+            (cooldown_seconds, cooldown_reason) 元组
+            - cooldown_seconds: 剩余冷却秒数，0表示无冷却，-1表示永久禁用
+            - cooldown_reason: 冷却原因，None表示无冷却
+        """
+        current_time = time.time()
+
+        # 优先检查429冷却期（无论账户是否可用）
+        if self.last_429_time > 0:
+            remaining_429 = self.rate_limit_cooldown_seconds - (current_time - self.last_429_time)
+            if remaining_429 > 0:
+                return (int(remaining_429), "429限流")
+            # 429冷却期已过
+
+        # 如果账户可用且没有429冷却，返回正常状态
+        if self.is_available:
+            return (0, None)
+
+        # 普通错误永久禁用
+        return (-1, "错误禁用")
+
+
+class MultiAccountManager:
+    """多账户协调器"""
+    def __init__(self, session_cache_ttl_seconds: int):
+        self.accounts: Dict[str, AccountManager] = {}
+        self.account_list: List[str] = []  # 账户ID列表 (用于轮询)
+        self.current_index = 0
+        self._cache_lock = asyncio.Lock()  # 缓存操作专用锁
+        self._index_lock = asyncio.Lock()  # 索引更新专用锁
+        # 全局会话缓存：{conv_key: {"account_id": str, "session_id": str, "updated_at": float}}
+        self.global_session_cache: Dict[str, dict] = {}
+        self.cache_max_size = 1000  # 最大缓存条目数
+        self.cache_ttl = session_cache_ttl_seconds  # 缓存过期时间（秒）
+        # Session级别锁：防止同一对话的并发请求冲突
+        self._session_locks: Dict[str, asyncio.Lock] = {}
+        self._session_locks_lock = asyncio.Lock()  # 保护锁字典的锁
+        self._session_locks_max_size = 2000  # 最大锁数量
+
+    def _clean_expired_cache(self):
+        """清理过期的缓存条目"""
+        current_time = time.time()
+        expired_keys = [
+            key for key, value in self.global_session_cache.items()
+            if current_time - value["updated_at"] > self.cache_ttl
+        ]
+        for key in expired_keys:
+            del self.global_session_cache[key]
+        if expired_keys:
+            logger.info(f"[CACHE] 清理 {len(expired_keys)} 个过期会话缓存")
+
+    def _ensure_cache_size(self):
+        """确保缓存不超过最大大小（LRU策略）"""
+        if len(self.global_session_cache) > self.cache_max_size:
+            # 按更新时间排序，删除最旧的20%
+            sorted_items = sorted(
+                self.global_session_cache.items(),
+                key=lambda x: x[1]["updated_at"]
+            )
+            remove_count = len(sorted_items) - int(self.cache_max_size * 0.8)
+            for key, _ in sorted_items[:remove_count]:
+                del self.global_session_cache[key]
+            logger.info(f"[CACHE] LRU清理 {remove_count} 个最旧会话缓存")
+
+    async def start_background_cleanup(self):
+        """启动后台缓存清理任务（每5分钟执行一次）"""
+        try:
+            while True:
+                await asyncio.sleep(300)  # 5分钟
+                async with self._cache_lock:
+                    self._clean_expired_cache()
+                    self._ensure_cache_size()
+        except asyncio.CancelledError:
+            logger.info("[CACHE] 后台清理任务已停止")
+        except Exception as e:
+            logger.error(f"[CACHE] 后台清理任务异常: {e}")
+
+    async def set_session_cache(self, conv_key: str, account_id: str, session_id: str):
+        """线程安全地设置会话缓存"""
+        async with self._cache_lock:
+            self.global_session_cache[conv_key] = {
+                "account_id": account_id,
+                "session_id": session_id,
+                "updated_at": time.time()
+            }
+            # 检查缓存大小
+            self._ensure_cache_size()
+
+    async def update_session_time(self, conv_key: str):
+        """线程安全地更新会话时间戳"""
+        async with self._cache_lock:
+            if conv_key in self.global_session_cache:
+                self.global_session_cache[conv_key]["updated_at"] = time.time()
+
+    async def acquire_session_lock(self, conv_key: str) -> asyncio.Lock:
+        """获取指定对话的锁（用于防止同一对话的并发请求冲突）"""
+        async with self._session_locks_lock:
+            # 清理过多的锁（LRU策略：删除不在缓存中的锁）
+            if len(self._session_locks) > self._session_locks_max_size:
+                # 只保留当前缓存中存在的锁
+                valid_keys = set(self.global_session_cache.keys())
+                keys_to_remove = [k for k in self._session_locks if k not in valid_keys]
+                for k in keys_to_remove[:len(keys_to_remove)//2]:  # 删除一半无效锁
+                    del self._session_locks[k]
+
+            if conv_key not in self._session_locks:
+                self._session_locks[conv_key] = asyncio.Lock()
+            return self._session_locks[conv_key]
+
+    def add_account(self, config: AccountConfig, http_client, user_agent: str, account_failure_threshold: int, rate_limit_cooldown_seconds: int, global_stats: dict):
+        """添加账户"""
+        manager = AccountManager(config, http_client, user_agent, account_failure_threshold, rate_limit_cooldown_seconds)
+        # 从统计数据加载对话次数
+        if "account_conversations" in global_stats:
+            manager.conversation_count = global_stats["account_conversations"].get(config.account_id, 0)
+        self.accounts[config.account_id] = manager
+        self.account_list.append(config.account_id)
+        logger.info(f"[MULTI] [ACCOUNT] 添加账户: {config.account_id}")
+
+    async def get_account(self, account_id: Optional[str] = None, request_id: str = "") -> AccountManager:
+        """获取账户 (轮询或指定) - 优化锁粒度，减少竞争"""
+        req_tag = f"[req_{request_id}] " if request_id else ""
+
+        # 如果指定了账户ID（无需锁）
+        if account_id:
+            if account_id not in self.accounts:
+                raise HTTPException(404, f"Account {account_id} not found")
+            account = self.accounts[account_id]
+            if not account.should_retry():
+                raise HTTPException(503, f"Account {account_id} temporarily unavailable")
+            return account
+
+        # 轮询选择可用账户（无锁读取账户列表）
+        available_accounts = [
+            acc_id for acc_id in self.account_list
+            if self.accounts[acc_id].should_retry()
+            and not self.accounts[acc_id].config.is_expired()
+            and not self.accounts[acc_id].config.disabled
+        ]
+
+        if not available_accounts:
+            raise HTTPException(503, "No available accounts")
+
+        # 只在更新索引时加锁（最小化锁持有时间）
+        async with self._index_lock:
+            if not hasattr(self, '_available_index'):
+                self._available_index = 0
+
+            account_id = available_accounts[self._available_index % len(available_accounts)]
+            self._available_index = (self._available_index + 1) % len(available_accounts)
+
+        account = self.accounts[account_id]
+        logger.info(f"[MULTI] [ACCOUNT] {req_tag}选择账户: {account_id}")
+        return account
+
+
+# ---------- 配置文件管理 ----------
+
+def save_accounts_to_file(accounts_data: list):
+    """保存账户配置到文件"""
+    with open(ACCOUNTS_FILE, 'w', encoding='utf-8') as f:
+        json.dump(accounts_data, f, ensure_ascii=False, indent=2)
+    logger.info(f"[CONFIG] 配置已保存到 {ACCOUNTS_FILE}")
+
+
+def load_accounts_from_source() -> list:
+    """优先从文件加载，否则从环境变量加载"""
+    # 优先从文件加载
+    if os.path.exists(ACCOUNTS_FILE):
+        try:
+            with open(ACCOUNTS_FILE, 'r', encoding='utf-8') as f:
+                accounts_data = json.load(f)
+            logger.info(f"[CONFIG] 从文件加载配置: {ACCOUNTS_FILE}")
+            return accounts_data
+        except Exception as e:
+            logger.warning(f"[CONFIG] 文件加载失败，尝试环境变量: {str(e)}")
+
+    # 从环境变量加载
+    accounts_json = os.getenv("ACCOUNTS_CONFIG")
+    if not accounts_json:
+        raise ValueError(
+            "未找到配置文件或 ACCOUNTS_CONFIG 环境变量。\n"
+            "请在环境变量中配置 JSON 格式的账户列表，格式示例：\n"
+            '[{"id":"account_1","csesidx":"xxx","config_id":"yyy","secure_c_ses":"zzz","host_c_oses":null,"expires_at":"2025-12-23 10:59:21"}]'
+        )
+
+    try:
+        accounts_data = json.loads(accounts_json)
+        if not isinstance(accounts_data, list):
+            raise ValueError("ACCOUNTS_CONFIG 必须是 JSON 数组格式")
+        # 首次从环境变量加载后，保存到文件
+        save_accounts_to_file(accounts_data)
+        logger.info(f"[CONFIG] 从环境变量加载配置并保存到文件")
+        return accounts_data
+    except json.JSONDecodeError as e:
+        logger.error(f"[CONFIG] ACCOUNTS_CONFIG JSON 解析失败: {str(e)}")
+        raise ValueError(f"ACCOUNTS_CONFIG 格式错误: {str(e)}")
+
+
+def get_account_id(acc: dict, index: int) -> str:
+    """获取账户ID（有显式ID则使用，否则生成默认ID）"""
+    return acc.get("id", f"account_{index}")
+
+
+def load_multi_account_config(
+    http_client,
+    user_agent: str,
+    account_failure_threshold: int,
+    rate_limit_cooldown_seconds: int,
+    session_cache_ttl_seconds: int,
+    global_stats: dict
+) -> MultiAccountManager:
+    """从文件或环境变量加载多账户配置"""
+    manager = MultiAccountManager(session_cache_ttl_seconds)
+
+    accounts_data = load_accounts_from_source()
+
+    for i, acc in enumerate(accounts_data, 1):
+        # 验证必需字段
+        required_fields = ["secure_c_ses", "csesidx", "config_id"]
+        missing_fields = [f for f in required_fields if f not in acc]
+        if missing_fields:
+            raise ValueError(f"账户 {i} 缺少必需字段: {', '.join(missing_fields)}")
+
+        config = AccountConfig(
+            account_id=get_account_id(acc, i),
+            secure_c_ses=acc["secure_c_ses"],
+            host_c_oses=acc.get("host_c_oses"),
+            csesidx=acc["csesidx"],
+            config_id=acc["config_id"],
+            expires_at=acc.get("expires_at"),
+            disabled=acc.get("disabled", False)  # 读取手动禁用状态，默认为 False
+        )
+
+        # 检查账户是否已过期
+        if config.is_expired():
+            logger.warning(f"[CONFIG] 账户 {config.account_id} 已过期，跳过加载")
+            continue
+
+        manager.add_account(config, http_client, user_agent, account_failure_threshold, rate_limit_cooldown_seconds, global_stats)
+
+    if not manager.accounts:
+        raise ValueError("没有有效的账户配置（可能全部已过期）")
+
+    logger.info(f"[CONFIG] 成功加载 {len(manager.accounts)} 个账户")
+    return manager
+
+
+def reload_accounts(
+    multi_account_mgr: MultiAccountManager,
+    http_client,
+    user_agent: str,
+    account_failure_threshold: int,
+    rate_limit_cooldown_seconds: int,
+    session_cache_ttl_seconds: int,
+    global_stats: dict
+) -> MultiAccountManager:
+    """重新加载账户配置（清空缓存并重新加载）"""
+    multi_account_mgr.global_session_cache.clear()
+    new_mgr = load_multi_account_config(
+        http_client,
+        user_agent,
+        account_failure_threshold,
+        rate_limit_cooldown_seconds,
+        session_cache_ttl_seconds,
+        global_stats
+    )
+    logger.info(f"[CONFIG] 配置已重载，当前账户数: {len(new_mgr.accounts)}")
+    return new_mgr
+
+
+def update_accounts_config(
+    accounts_data: list,
+    multi_account_mgr: MultiAccountManager,
+    http_client,
+    user_agent: str,
+    account_failure_threshold: int,
+    rate_limit_cooldown_seconds: int,
+    session_cache_ttl_seconds: int,
+    global_stats: dict
+) -> MultiAccountManager:
+    """更新账户配置（保存到文件并重新加载）"""
+    save_accounts_to_file(accounts_data)
+    return reload_accounts(
+        multi_account_mgr,
+        http_client,
+        user_agent,
+        account_failure_threshold,
+        rate_limit_cooldown_seconds,
+        session_cache_ttl_seconds,
+        global_stats
+    )
+
+
+def delete_account(
+    account_id: str,
+    multi_account_mgr: MultiAccountManager,
+    http_client,
+    user_agent: str,
+    account_failure_threshold: int,
+    rate_limit_cooldown_seconds: int,
+    session_cache_ttl_seconds: int,
+    global_stats: dict
+) -> MultiAccountManager:
+    """删除单个账户"""
+    accounts_data = load_accounts_from_source()
+
+    # 过滤掉要删除的账户
+    filtered = [
+        acc for i, acc in enumerate(accounts_data, 1)
+        if get_account_id(acc, i) != account_id
+    ]
+
+    if len(filtered) == len(accounts_data):
+        raise ValueError(f"账户 {account_id} 不存在")
+
+    save_accounts_to_file(filtered)
+    return reload_accounts(
+        multi_account_mgr,
+        http_client,
+        user_agent,
+        account_failure_threshold,
+        rate_limit_cooldown_seconds,
+        session_cache_ttl_seconds,
+        global_stats
+    )
+
+
+def update_account_disabled_status(
+    account_id: str,
+    disabled: bool,
+    multi_account_mgr: MultiAccountManager,
+    http_client,
+    user_agent: str,
+    account_failure_threshold: int,
+    rate_limit_cooldown_seconds: int,
+    session_cache_ttl_seconds: int,
+    global_stats: dict
+) -> MultiAccountManager:
+    """更新账户的禁用状态"""
+    accounts_data = load_accounts_from_source()
+
+    # 查找并更新账户
+    found = False
+    for i, acc in enumerate(accounts_data, 1):
+        if get_account_id(acc, i) == account_id:
+            acc["disabled"] = disabled
+            found = True
+            break
+
+    if not found:
+        raise ValueError(f"账户 {account_id} 不存在")
+
+    save_accounts_to_file(accounts_data)
+    new_mgr = reload_accounts(
+        multi_account_mgr,
+        http_client,
+        user_agent,
+        account_failure_threshold,
+        rate_limit_cooldown_seconds,
+        session_cache_ttl_seconds,
+        global_stats
+    )
+
+    status_text = "已禁用" if disabled else "已启用"
+    logger.info(f"[CONFIG] 账户 {account_id} {status_text}")
+    return new_mgr

core/auth.py

@@ -1,122 +1,47 @@
 """
-认证相关装饰器和工具函数
+API认证模块
+提供API Key验证功能（用于API端点）
+管理端点使用Session认证（见core/session_auth.py）
 """
-from functools import wraps
-from fastapi import HTTPException, Header
 from typing import Optional
+from fastapi import HTTPException
 
 
-def extract_admin_key(key: Optional[str] = None, authorization: Optional[str] = None) -> Optional[str]:
+def verify_api_key(api_key_value: str, authorization: Optional[str] = None) -> bool:
     """
-    统一提取管理员密钥
-
-    优先级：
-    1. URL 参数 ?key=xxx
-    2. Authorization Header (支持 Bearer token 格式)
-
-    Args:
-        key: URL 查询参数中的密钥
-        authorization: Authorization Header 中的密钥
-
-    Returns:
-        提取到的密钥，如果都为空则返回 None
-    """
-    if key:
-        return key
-    if authorization:
-        # 支持 Bearer token 格式
-        return authorization.replace("Bearer ", "") if authorization.startswith("Bearer ") else authorization
-    return None
-
-
-def require_path_prefix(path_prefix_value: str):
-    """
-    验证路径前缀的装饰器
-
-    Args:
-        path_prefix_value: 正确的路径前缀值
-
-    Returns:
-        装饰器函数
-
-    Example:
-        @app.get("/{path_prefix}/admin")
-        @require_path_prefix(PATH_PREFIX)
-        async def admin_home(path_prefix: str, ...):
-            ...
-    """
-    def decorator(func):
-        @wraps(func)
-        async def wrapper(*args, path_prefix: str, **kwargs):
-            if path_prefix != path_prefix_value:
-                # 返回 404 而不是 401，假装端点不存在（安全性考虑）
-                raise HTTPException(404, "Not Found")
-            return await func(*args, path_prefix=path_prefix, **kwargs)
-        return wrapper
-    return decorator
-
-
-def require_admin_auth(admin_key_value: str):
-    """
-    验证管理员权限的装饰器
-
-    支持两种认证方式：
-    1. URL 参数：?key=xxx
-    2. Authorization Header：Bearer xxx 或直接传密钥
-
-    Args:
-        admin_key_value: 正确的管理员密钥
-
-    Returns:
-        装饰器函数
-
-    Example:
-        @app.get("/{path_prefix}/admin")
-        @require_admin_auth(ADMIN_KEY)
-        async def admin_home(key: str = None, authorization: str = Header(None), ...):
-            ...
-    """
-    def decorator(func):
-        @wraps(func)
-        async def wrapper(*args, key: str = None, authorization: str = Header(None), **kwargs):
-            admin_key = extract_admin_key(key, authorization)
-            if admin_key != admin_key_value:
-                # 返回 404 而不是 401，假装端点不存在（安全性考虑）
-                raise HTTPException(404, "Not Found")
-            return await func(*args, key=key, authorization=authorization, **kwargs)
-        return wrapper
-    return decorator
-
-
-def require_path_and_admin(path_prefix_value: str, admin_key_value: str):
-    """
-    同时验证路径前缀和管理员权限的组合装饰器
+    验证 API Key
 
     Args:
-        path_prefix_value: 正确的路径前缀值
-        admin_key_value: 正确的管理员密钥
+        api_key_value: 配置的API Key值（如果为空则跳过验证）
+        authorization: Authorization Header中的值
 
     Returns:
-        装饰器函数
-
-    Example:
-        @app.get("/{path_prefix}/admin")
-        @require_path_and_admin(PATH_PREFIX, ADMIN_KEY)
-        async def admin_home(path_prefix: str, key: str = None, authorization: str = Header(None), ...):
-            ...
-    """
-    def decorator(func):
-        @wraps(func)
-        async def wrapper(*args, path_prefix: str, key: str = None, authorization: str = Header(None), **kwargs):
-            # 验证路径前缀
-            if path_prefix != path_prefix_value:
-                raise HTTPException(404, "Not Found")
-
-            # 验证管理员密钥
-            admin_key = extract_admin_key(key, authorization)
-            if admin_key != admin_key_value:
-                raise HTTPException(404, "Not Found")
-
-            return await func(*args, path_prefix=path_prefix, key=key, authorization=authorization, **kwargs)
-        return wrapper
-    return decorator
+        验证通过返回True，否则抛出HTTPException
+
+    支持格式：
+    1. Bearer YOUR_API_KEY
+    2. YOUR_API_KEY
+    """
+    # 如果未配置 API_KEY，则跳过验证
+    if not api_key_value:
+        return True
+
+    # 检查 Authorization header
+    if not authorization:
+        raise HTTPException(
+            status_code=401,
+            detail="Missing Authorization header"
+        )
+
+    # 提取token（支持Bearer格式）
+    token = authorization
+    if authorization.startswith("Bearer "):
+        token = authorization[7:]
+
+    if token != api_key_value:
+        raise HTTPException(
+            status_code=401,
+            detail="Invalid API Key"
+        )
+
+    return True

core/google_api.py

@@ -0,0 +1,304 @@
+"""Google API交互模块
+
+负责与Google Gemini Business API的所有交互操作
+"""
+import asyncio
+import logging
+import os
+import time
+import uuid
+from typing import TYPE_CHECKING, List
+
+import httpx
+from fastapi import HTTPException
+
+if TYPE_CHECKING:
+    from main import AccountManager
+
+logger = logging.getLogger(__name__)
+
+# Google API 基础URL
+GEMINI_API_BASE = "https://biz-discoveryengine.googleapis.com/v1alpha"
+
+
+def get_common_headers(jwt: str, user_agent: str) -> dict:
+    """生成通用请求头"""
+    return {
+        "accept": "*/*",
+        "accept-encoding": "gzip, deflate, br, zstd",
+        "accept-language": "zh-CN,zh;q=0.9,en;q=0.8",
+        "authorization": f"Bearer {jwt}",
+        "content-type": "application/json",
+        "origin": "https://business.gemini.google",
+        "referer": "https://business.gemini.google/",
+        "user-agent": user_agent,
+        "x-server-timeout": "1800",
+        "sec-ch-ua": '"Chromium";v="124", "Google Chrome";v="124", "Not-A.Brand";v="99"',
+        "sec-ch-ua-mobile": "?0",
+        "sec-ch-ua-platform": '"Windows"',
+        "sec-fetch-dest": "empty",
+        "sec-fetch-mode": "cors",
+        "sec-fetch-site": "cross-site",
+    }
+
+
+async def make_request_with_jwt_retry(
+    account_mgr: "AccountManager",
+    method: str,
+    url: str,
+    http_client: httpx.AsyncClient,
+    user_agent: str,
+    request_id: str = "",
+    **kwargs
+) -> httpx.Response:
+    """通用HTTP请求，自动处理JWT过期重试
+
+    Args:
+        account_mgr: AccountManager实例
+        method: HTTP方法 (GET/POST)
+        url: 请求URL
+        http_client: httpx客户端
+        user_agent: User-Agent字符串
+        request_id: 请求ID（用于日志）
+        **kwargs: 传递给httpx的其他参数（如json, headers等）
+
+    Returns:
+        httpx.Response对象
+    """
+    jwt = await account_mgr.get_jwt(request_id)
+    headers = get_common_headers(jwt, user_agent)
+
+    # 合并用户提供的headers（如果有）
+    if "headers" in kwargs:
+        headers.update(kwargs.pop("headers"))
+
+    # 发起请求
+    if method.upper() == "GET":
+        resp = await http_client.get(url, headers=headers, **kwargs)
+    elif method.upper() == "POST":
+        resp = await http_client.post(url, headers=headers, **kwargs)
+    else:
+        raise ValueError(f"Unsupported HTTP method: {method}")
+
+    # 如果401，刷新JWT后重试一次
+    if resp.status_code == 401:
+        jwt = await account_mgr.get_jwt(request_id)
+        headers = get_common_headers(jwt, user_agent)
+        if "headers" in kwargs:
+            headers.update(kwargs["headers"])
+
+        if method.upper() == "GET":
+            resp = await http_client.get(url, headers=headers, **kwargs)
+        elif method.upper() == "POST":
+            resp = await http_client.post(url, headers=headers, **kwargs)
+
+    return resp
+
+
+async def create_google_session(
+    account_manager: "AccountManager",
+    http_client: httpx.AsyncClient,
+    user_agent: str,
+    request_id: str = ""
+) -> str:
+    """创建Google Session"""
+    jwt = await account_manager.get_jwt(request_id)
+    headers = get_common_headers(jwt, user_agent)
+    body = {
+        "configId": account_manager.config.config_id,
+        "additionalParams": {"token": "-"},
+        "createSessionRequest": {
+            "session": {"name": "", "displayName": ""}
+        }
+    }
+
+    req_tag = f"[req_{request_id}] " if request_id else ""
+    r = await http_client.post(
+        f"{GEMINI_API_BASE}/locations/global/widgetCreateSession",
+        headers=headers,
+        json=body,
+    )
+    if r.status_code != 200:
+        logger.error(f"[SESSION] [{account_manager.config.account_id}] {req_tag}Session 创建失败: {r.status_code}")
+        raise HTTPException(r.status_code, "createSession failed")
+    sess_name = r.json()["session"]["name"]
+    logger.info(f"[SESSION] [{account_manager.config.account_id}] {req_tag}创建成功: {sess_name[-12:]}")
+    return sess_name
+
+
+async def upload_context_file(
+    session_name: str,
+    mime_type: str,
+    base64_content: str,
+    account_manager: "AccountManager",
+    http_client: httpx.AsyncClient,
+    user_agent: str,
+    request_id: str = ""
+) -> str:
+    """上传文件到指定 Session，返回 fileId"""
+    jwt = await account_manager.get_jwt(request_id)
+    headers = get_common_headers(jwt, user_agent)
+
+    # 生成随机文件名
+    ext = mime_type.split('/')[-1] if '/' in mime_type else "bin"
+    file_name = f"upload_{int(time.time())}_{uuid.uuid4().hex[:6]}.{ext}"
+
+    body = {
+        "configId": account_manager.config.config_id,
+        "additionalParams": {"token": "-"},
+        "addContextFileRequest": {
+            "name": session_name,
+            "fileName": file_name,
+            "mimeType": mime_type,
+            "fileContents": base64_content
+        }
+    }
+
+    r = await http_client.post(
+        f"{GEMINI_API_BASE}/locations/global/widgetAddContextFile",
+        headers=headers,
+        json=body,
+    )
+
+    req_tag = f"[req_{request_id}] " if request_id else ""
+    if r.status_code != 200:
+        logger.error(f"[FILE] [{account_manager.config.account_id}] {req_tag}文件上传失败: {r.status_code}")
+        raise HTTPException(r.status_code, f"Upload failed: {r.text}")
+
+    data = r.json()
+    file_id = data.get("addContextFileResponse", {}).get("fileId")
+    logger.info(f"[FILE] [{account_manager.config.account_id}] {req_tag}文件上传成功: {mime_type}")
+    return file_id
+
+
+async def get_session_file_metadata(
+    account_mgr: "AccountManager",
+    session_name: str,
+    http_client: httpx.AsyncClient,
+    user_agent: str,
+    request_id: str = ""
+) -> dict:
+    """获取session中的文件元数据，包括正确的session路径"""
+    body = {
+        "configId": account_mgr.config.config_id,
+        "additionalParams": {"token": "-"},
+        "listSessionFileMetadataRequest": {
+            "name": session_name,
+            "filter": "file_origin_type = AI_GENERATED"
+        }
+    }
+
+    resp = await make_request_with_jwt_retry(
+        account_mgr,
+        "POST",
+        f"{GEMINI_API_BASE}/locations/global/widgetListSessionFileMetadata",
+        http_client,
+        user_agent,
+        request_id,
+        json=body
+    )
+
+    if resp.status_code != 200:
+        logger.warning(f"[IMAGE] [{account_mgr.config.account_id}] [req_{request_id}] 获取文件元数据失败: {resp.status_code}")
+        return {}
+
+    data = resp.json()
+    result = {}
+    file_metadata_list = data.get("listSessionFileMetadataResponse", {}).get("fileMetadata", [])
+
+    for fm in file_metadata_list:
+        fid = fm.get("fileId")
+        if fid:
+            result[fid] = fm
+
+    return result
+
+
+def build_image_download_url(session_name: str, file_id: str) -> str:
+    """构造图片下载URL"""
+    return f"{GEMINI_API_BASE}/{session_name}:downloadFile?fileId={file_id}&alt=media"
+
+
+async def download_image_with_jwt(
+    account_mgr: "AccountManager",
+    session_name: str,
+    file_id: str,
+    http_client: httpx.AsyncClient,
+    user_agent: str,
+    request_id: str = "",
+    max_retries: int = 3
+) -> bytes:
+    """
+    使用JWT认证下载图片（带超时和重试机制）
+
+    Args:
+        account_mgr: 账户管理器
+        session_name: Session名称
+        file_id: 文件ID
+        http_client: httpx客户端
+        user_agent: User-Agent字符串
+        request_id: 请求ID
+        max_retries: 最大重试次数（默认3次）
+
+    Returns:
+        图片字节数据
+
+    Raises:
+        HTTPException: 下载失败
+        asyncio.TimeoutError: 超时
+    """
+    url = build_image_download_url(session_name, file_id)
+    logger.info(f"[IMAGE] [{account_mgr.config.account_id}] [req_{request_id}] 开始下载图片: {file_id[:8]}...")
+
+    for attempt in range(max_retries):
+        try:
+            # 3分钟超时（180秒）
+            async with asyncio.timeout(180):
+                # 使用通用JWT刷新函数
+                resp = await make_request_with_jwt_retry(
+                    account_mgr,
+                    "GET",
+                    url,
+                    http_client,
+                    user_agent,
+                    request_id,
+                    follow_redirects=True
+                )
+
+                resp.raise_for_status()
+                logger.info(f"[IMAGE] [{account_mgr.config.account_id}] [req_{request_id}] 图片下载成功: {file_id[:8]}... ({len(resp.content)} bytes)")
+                return resp.content
+
+        except asyncio.TimeoutError:
+            logger.warning(f"[IMAGE] [{account_mgr.config.account_id}] [req_{request_id}] 图片下载超时 (尝试 {attempt + 1}/{max_retries}): {file_id[:8]}...")
+            if attempt == max_retries - 1:
+                raise HTTPException(504, f"Image download timeout after {max_retries} attempts")
+            await asyncio.sleep(2 ** attempt)  # 指数退避：2s, 4s, 8s
+
+        except httpx.HTTPError as e:
+            logger.warning(f"[IMAGE] [{account_mgr.config.account_id}] [req_{request_id}] 图片下载失败 (尝试 {attempt + 1}/{max_retries}): {type(e).__name__}")
+            if attempt == max_retries - 1:
+                raise HTTPException(500, f"Image download failed: {str(e)[:100]}")
+            await asyncio.sleep(2 ** attempt)  # 指数退避
+
+        except Exception as e:
+            logger.error(f"[IMAGE] [{account_mgr.config.account_id}] [req_{request_id}] 图片下载异常: {type(e).__name__}: {str(e)[:100]}")
+            raise
+
+    # 不应该到达这里
+    raise HTTPException(500, "Image download failed unexpectedly")
+
+
+def save_image_to_hf(image_data: bytes, chat_id: str, file_id: str, mime_type: str, base_url: str, image_dir: str) -> str:
+    """保存图片到持久化存储,返回完整的公开URL"""
+    ext_map = {"image/png": ".png", "image/jpeg": ".jpg", "image/gif": ".gif", "image/webp": ".webp"}
+    ext = ext_map.get(mime_type, ".png")
+
+    filename = f"{chat_id}_{file_id}{ext}"
+    save_path = os.path.join(image_dir, filename)
+
+    # 目录已在启动时创建,无需重复创建
+    with open(save_path, "wb") as f:
+        f.write(image_data)
+
+    return f"{base_url}/images/{filename}"

core/jwt.py

@@ -0,0 +1,101 @@
+"""JWT管理模块
+
+负责JWT token的生成、刷新和管理
+"""
+import asyncio
+import base64
+import hashlib
+import hmac
+import json
+import logging
+import time
+from typing import TYPE_CHECKING
+
+import httpx
+from fastapi import HTTPException
+
+if TYPE_CHECKING:
+    from main import AccountConfig
+
+logger = logging.getLogger(__name__)
+
+
+def urlsafe_b64encode(data: bytes) -> str:
+    return base64.urlsafe_b64encode(data).decode().rstrip("=")
+
+def kq_encode(s: str) -> str:
+    b = bytearray()
+    for ch in s:
+        v = ord(ch)
+        if v > 255:
+            b.append(v & 255)
+            b.append(v >> 8)
+        else:
+            b.append(v)
+    return urlsafe_b64encode(bytes(b))
+
+def create_jwt(key_bytes: bytes, key_id: str, csesidx: str) -> str:
+    now = int(time.time())
+    header = {"alg": "HS256", "typ": "JWT", "kid": key_id}
+    payload = {
+        "iss": "https://business.gemini.google",
+        "aud": "https://biz-discoveryengine.googleapis.com",
+        "sub": f"csesidx/{csesidx}",
+        "iat": now,
+        "exp": now + 300,
+        "nbf": now,
+    }
+    header_b64  = kq_encode(json.dumps(header, separators=(",", ":")))
+    payload_b64 = kq_encode(json.dumps(payload, separators=(",", ":")))
+    message     = f"{header_b64}.{payload_b64}"
+    sig         = hmac.new(key_bytes, message.encode(), hashlib.sha256).digest()
+    return f"{message}.{urlsafe_b64encode(sig)}"
+
+
+class JWTManager:
+    """JWT token管理器
+
+    负责JWT的获取、刷新和缓存
+    """
+    def __init__(self, config: "AccountConfig", http_client: httpx.AsyncClient, user_agent: str) -> None:
+        self.config = config
+        self.http_client = http_client
+        self.user_agent = user_agent
+        self.jwt: str = ""
+        self.expires: float = 0
+        self._lock = asyncio.Lock()
+
+    async def get(self, request_id: str = "") -> str:
+        """获取JWT token（自动刷新）"""
+        async with self._lock:
+            if time.time() > self.expires:
+                await self._refresh(request_id)
+            return self.jwt
+
+    async def _refresh(self, request_id: str = "") -> None:
+        """刷新JWT token"""
+        cookie = f"__Secure-C_SES={self.config.secure_c_ses}"
+        if self.config.host_c_oses:
+            cookie += f"; __Host-C_OSES={self.config.host_c_oses}"
+
+        req_tag = f"[req_{request_id}] " if request_id else ""
+        r = await self.http_client.get(
+            "https://business.gemini.google/auth/getoxsrf",
+            params={"csesidx": self.config.csesidx},
+            headers={
+                "cookie": cookie,
+                "user-agent": self.user_agent,
+                "referer": "https://business.gemini.google/"
+            },
+        )
+        if r.status_code != 200:
+            logger.error(f"[AUTH] [{self.config.account_id}] {req_tag}JWT 刷新失败: {r.status_code}")
+            raise HTTPException(r.status_code, "getoxsrf failed")
+
+        txt = r.text[4:] if r.text.startswith(")]}'") else r.text
+        data = json.loads(txt)
+
+        key_bytes = base64.urlsafe_b64decode(data["xsrfToken"] + "==")
+        self.jwt      = create_jwt(key_bytes, data["keyId"], self.config.csesidx)
+        self.expires = time.time() + 270
+        logger.info(f"[AUTH] [{self.config.account_id}] {req_tag}JWT 刷新成功")

core/message.py

@@ -0,0 +1,141 @@
+"""消息处理模块
+
+负责消息的解析、文本提取和会话指纹生成
+"""
+import asyncio
+import base64
+import hashlib
+import logging
+import re
+from typing import List, TYPE_CHECKING
+
+import httpx
+
+if TYPE_CHECKING:
+    from main import Message
+
+logger = logging.getLogger(__name__)
+
+
+def get_conversation_key(messages: List[dict], client_identifier: str = "") -> str:
+    """
+    生成对话指纹（使用前3条消息+客户端标识，确保唯一性）
+
+    策略：
+    1. 使用前3条消息生成指纹（而非仅第1条）
+    2. 加入客户端标识（IP或request_id）避免不同用户冲突
+    3. 保持Session复用能力（同一用户的后续消息仍能找到同一Session）
+
+    Args:
+        messages: 消息列表
+        client_identifier: 客户端标识（如IP地址或request_id），用于区分不同用户
+    """
+    if not messages:
+        return f"{client_identifier}:empty" if client_identifier else "empty"
+
+    # 提取前3条消息的关键信息（角色+内容）
+    message_fingerprints = []
+    for msg in messages[:3]:  # 只取前3条
+        role = msg.get("role", "")
+        content = msg.get("content", "")
+
+        # 统一处理内容格式（字符串或数组）
+        if isinstance(content, list):
+            # 多模态消息：只提取文本部分
+            text = extract_text_from_content(content)
+        else:
+            text = str(content)
+
+        # 标准化：去除首尾空白，转小写
+        text = text.strip().lower()
+
+        # 组合角色和内容
+        message_fingerprints.append(f"{role}:{text}")
+
+    # 使用前3条消息+客户端标识生成指纹
+    conversation_prefix = "|".join(message_fingerprints)
+    if client_identifier:
+        conversation_prefix = f"{client_identifier}|{conversation_prefix}"
+
+    return hashlib.md5(conversation_prefix.encode()).hexdigest()
+
+
+def extract_text_from_content(content) -> str:
+    """
+    从消息 content 中提取文本内容
+    统一处理字符串和多模态数组格式
+    """
+    if isinstance(content, str):
+        return content
+    elif isinstance(content, list):
+        # 多模态消息：只提取文本部分
+        return "".join([x.get("text", "") for x in content if x.get("type") == "text"])
+    else:
+        return str(content)
+
+
+async def parse_last_message(messages: List['Message'], http_client: httpx.AsyncClient, request_id: str = ""):
+    """解析最后一条消息，分离文本和文件（支持图片、PDF、文档等，base64 和 URL）"""
+    if not messages:
+        return "", []
+
+    last_msg = messages[-1]
+    content = last_msg.content
+
+    text_content = ""
+    images = [] # List of {"mime": str, "data": str_base64} - 兼容变量名，实际支持所有文件
+    image_urls = []  # 需要下载的 URL - 兼容变量名，实际支持所有文件
+
+    if isinstance(content, str):
+        text_content = content
+    elif isinstance(content, list):
+        for part in content:
+            if part.get("type") == "text":
+                text_content += part.get("text", "")
+            elif part.get("type") == "image_url":
+                url = part.get("image_url", {}).get("url", "")
+                # 解析 Data URI: data:mime/type;base64,xxxxxx (支持所有 MIME 类型)
+                match = re.match(r"data:([^;]+);base64,(.+)", url)
+                if match:
+                    images.append({"mime": match.group(1), "data": match.group(2)})
+                elif url.startswith(("http://", "https://")):
+                    image_urls.append(url)
+                else:
+                    logger.warning(f"[FILE] [req_{request_id}] 不支持的文件格式: {url[:30]}...")
+
+    # 并行下载所有 URL 文件（支持图片、PDF、文档等）
+    if image_urls:
+        async def download_url(url: str):
+            try:
+                resp = await http_client.get(url, timeout=30, follow_redirects=True)
+                resp.raise_for_status()
+                content_type = resp.headers.get("content-type", "application/octet-stream").split(";")[0]
+                # 移除图片类型限制，支持所有文件类型
+                b64 = base64.b64encode(resp.content).decode()
+                logger.info(f"[FILE] [req_{request_id}] URL文件下载成功: {url[:50]}... ({len(resp.content)} bytes, {content_type})")
+                return {"mime": content_type, "data": b64}
+            except Exception as e:
+                logger.warning(f"[FILE] [req_{request_id}] URL文件下载失败: {url[:50]}... - {e}")
+                return None
+
+        results = await asyncio.gather(*[download_url(u) for u in image_urls])
+        images.extend([r for r in results if r])
+
+    return text_content, images
+
+
+def build_full_context_text(messages: List['Message']) -> str:
+    """仅拼接历史文本，图片只处理当��请求的"""
+    prompt = ""
+    for msg in messages:
+        role = "User" if msg.role in ["user", "system"] else "Assistant"
+        content_str = extract_text_from_content(msg.content)
+
+        # 为多模态消息添加图片标记
+        if isinstance(msg.content, list):
+            image_count = sum(1 for part in msg.content if part.get("type") == "image_url")
+            if image_count > 0:
+                content_str += "[图片]" * image_count
+
+        prompt += f"{role}: {content_str}\n\n"
+    return prompt

core/session_auth.py

@@ -0,0 +1,65 @@
+"""
+Session认证模块
+提供基于Session的登录认证功能
+"""
+import secrets
+from functools import wraps
+from typing import Optional
+from fastapi import HTTPException, Request, Response
+from fastapi.responses import RedirectResponse
+
+
+def generate_session_secret() -> str:
+    """生成随机的session密钥"""
+    return secrets.token_hex(32)
+
+
+def is_logged_in(request: Request) -> bool:
+    """检查用户是否已登录"""
+    return request.session.get("authenticated", False)
+
+
+def login_user(request: Request):
+    """标记用户为已登录状态"""
+    request.session["authenticated"] = True
+
+
+def logout_user(request: Request):
+    """清除用户登录状态"""
+    request.session.clear()
+
+
+def require_login(redirect_to_login: bool = True):
+    """
+    要求用户登录的装饰器
+
+    Args:
+        redirect_to_login: 未登录时是否重定向到登录页面（默认True）
+                          False时返回404错误
+    """
+    def decorator(func):
+        @wraps(func)
+        async def wrapper(*args, request: Request, **kwargs):
+            if not is_logged_in(request):
+                if redirect_to_login:
+                    # 构建登录页面URL（支持可选的PATH_PREFIX）
+                    # 从请求路径中提取PATH_PREFIX（如果有）
+                    path = request.url.path
+
+                    # 动态导入main模块获取PATH_PREFIX（避免循环依赖）
+                    import main
+                    prefix = main.PATH_PREFIX
+
+                    if prefix:
+                        login_url = f"/{prefix}/login"
+                    else:
+                        login_url = "/admin/login"
+
+                    return RedirectResponse(url=login_url, status_code=302)
+                else:
+                    # 返回404假装端点不存在
+                    raise HTTPException(404, "Not Found")
+
+            return await func(*args, request=request, **kwargs)
+        return wrapper
+    return decorator

core/templates.py

@@ -27,26 +27,14 @@ def generate_admin_html(request: Request, multi_account_mgr, show_hide_tip: bool
                 error_count += 1
 
     # --- 1. 构建提示信息 ---
-    hide_tip = ""
-    if show_hide_tip:
-        hide_tip = """
-        <div class="alert alert-info">
-            <div class="alert-icon">💡</div>
-            <div class="alert-content">
-                <strong>提示</strong>：此页面默认在首页显示。如需隐藏，请设置环境变量：<br>
-                <code style="margin-top:4px; display:inline-block;">main.HIDE_HOME_PAGE=true</code>
-            </div>
-        </div>
-        """
-
     api_key_status = ""
     if main.API_KEY:
         api_key_status = """
         <div class="alert alert-success">
             <div class="alert-icon">🔒</div>
             <div class="alert-content">
-                <strong>安全模式已启用</strong>
-                <div class="alert-desc">请求 Header 需携带 Authorization 密钥。</div>
+                <strong>API 安全模式已启用</strong>
+                <div class="alert-desc">API 端点需要携带 Authorization 密钥才能访问。</div>
             </div>
         </div>
         """
@@ -55,8 +43,8 @@ def generate_admin_html(request: Request, multi_account_mgr, show_hide_tip: bool
         <div class="alert alert-warning">
             <div class="alert-icon">⚠️</div>
             <div class="alert-content">
-                <strong>API Key 未设置</strong>
-                <div class="alert-desc">API 当前允许公开访问，建议配置 main.API_KEY。</div>
+                <strong>API 密钥未设置</strong>
+                <div class="alert-desc">API 端点当前允许公开访问。建议在 .env 文件中配置 <code>API_KEY</code> 环境变量以提升安全性。</div>
             </div>
         </div>
         """
@@ -74,7 +62,16 @@ def generate_admin_html(request: Request, multi_account_mgr, show_hide_tip: bool
         """
 
     # API接口信息提示
-    api_endpoint = f"{current_url}/{main.PATH_PREFIX}/v1/chat/completions"
+    # 生成正确的API端点URL和管理端点URL
+    # admin_path_segment: 有PATH_PREFIX时为 secret123，无时为 admin
+    # 管理端点示例：/{admin_path_segment}/accounts
+    admin_path_segment = f"{main.PATH_PREFIX}" if main.PATH_PREFIX else "admin"
+    api_path_segment = f"{main.PATH_PREFIX}/" if main.PATH_PREFIX else ""
+
+    # 构建不同客户端需要的接口
+    api_base_url = f"{current_url}/{api_path_segment.rstrip('/')}" if api_path_segment else current_url
+    api_base_v1 = f"{current_url}/{api_path_segment}v1"
+    api_endpoint = f"{current_url}/{api_path_segment}v1/chat/completions"
     api_key_display = main.API_KEY if main.API_KEY else '<span style="color: #ff9500;">未设置（公开访问）</span>'
 
     api_info_tip = f"""
@@ -84,7 +81,15 @@ def generate_admin_html(request: Request, multi_account_mgr, show_hide_tip: bool
             <strong>API 接口信息</strong>
             <div style="margin-top: 10px;">
                 <div style="margin-bottom: 12px;">
-                    <div style="color: #86868b; font-size: 11px; margin-bottom: 4px;">聊天接口</div>
+                    <div style="color: #86868b; font-size: 11px; margin-bottom: 4px;">基础端点（部分客户端）</div>
+                    <code style="font-size: 11px; background: rgba(0,0,0,0.05); padding: 4px 8px; border-radius: 4px; display: inline-block; word-break: break-all;">{api_base_url}</code>
+                </div>
+                <div style="margin-bottom: 12px;">
+                    <div style="color: #86868b; font-size: 11px; margin-bottom: 4px;">API Base（OpenAI SDK 等）</div>
+                    <code style="font-size: 11px; background: rgba(0,0,0,0.05); padding: 4px 8px; border-radius: 4px; display: inline-block; word-break: break-all;">{api_base_v1}</code>
+                </div>
+                <div style="margin-bottom: 12px;">
+                    <div style="color: #86868b; font-size: 11px; margin-bottom: 4px;">完整聊天接口（直接调用）</div>
                     <code style="font-size: 11px; background: rgba(0,0,0,0.05); padding: 4px 8px; border-radius: 4px; display: inline-block; word-break: break-all;">{api_endpoint}</code>
                 </div>
                 <div style="margin-bottom: 12px;">
@@ -114,8 +119,8 @@ def generate_admin_html(request: Request, multi_account_mgr, show_hide_tip: bool
     </div>
     """
 
-    # --- 2. 构建账户卡片 ---
-    accounts_html = ""
+    # --- 2. 构建账户表格行 ---
+    accounts_rows = ""
     for account_id, account_manager in multi_account_mgr.accounts.items():
         config = account_manager.config
         remaining_hours = config.get_remaining_hours()
@@ -133,36 +138,36 @@ def generate_admin_html(request: Request, multi_account_mgr, show_hide_tip: bool
             status_text = "过期禁用"
             status_color = "#9e9e9e"
             dot_color = "#9e9e9e"
-            card_opacity = "0.5"
-            action_buttons = f'<button onclick="deleteAccount(\'{config.account_id}\')" class="delete-btn" title="删除账户">删除</button>'
+            row_opacity = "0.5"
+            action_buttons = f'<button onclick="deleteAccount(\'{config.account_id}\')" class="btn-sm btn-delete" title="删除">删除</button>'
         elif is_disabled:
             status_text = "手动禁用"
             status_color = "#9e9e9e"
             dot_color = "#9e9e9e"
-            card_opacity = "0.5"
+            row_opacity = "0.5"
             action_buttons = f'''
-                <button onclick="enableAccount('{config.account_id}')" class="enable-btn" title="启用账户">启用</button>
-                <button onclick="deleteAccount('{config.account_id}')" class="delete-btn" title="删除账户">删除</button>
+                <button onclick="enableAccount('{config.account_id}')" class="btn-sm btn-enable" title="启用">启用</button>
+                <button onclick="deleteAccount('{config.account_id}')" class="btn-sm btn-delete" title="删除">删除</button>
             '''
         elif cooldown_seconds == -1:
             # 错误永久禁用
             status_text = cooldown_reason  # "错误禁用"
             status_color = "#f44336"
             dot_color = "#f44336"
-            card_opacity = "0.5"
+            row_opacity = "0.5"
             action_buttons = f'''
-                <button onclick="enableAccount('{config.account_id}')" class="enable-btn" title="启用账户">启用</button>
-                <button onclick="deleteAccount('{config.account_id}')" class="delete-btn" title="删除账户">删除</button>
+                <button onclick="enableAccount('{config.account_id}')" class="btn-sm btn-enable" title="启用">启用</button>
+                <button onclick="deleteAccount('{config.account_id}')" class="btn-sm btn-delete" title="删除">删除</button>
             '''
         elif cooldown_seconds > 0:
             # 429限流（冷却中）
-            status_text = cooldown_reason  # "429限流"
+            status_text = f"{cooldown_reason} ({cooldown_seconds}s)"
             status_color = "#ff9800"
             dot_color = "#ff9800"
-            card_opacity = "1"
+            row_opacity = "1"
             action_buttons = f'''
-                <button onclick="disableAccount('{config.account_id}')" class="disable-btn" title="禁用账户">禁用</button>
-                <button onclick="deleteAccount('{config.account_id}')" class="delete-btn" title="删除账户">删除</button>
+                <button onclick="disableAccount('{config.account_id}')" class="btn-sm btn-disable" title="禁用">禁用</button>
+                <button onclick="deleteAccount('{config.account_id}')" class="btn-sm btn-delete" title="删除">删除</button>
             '''
         else:
             # 正常状态
@@ -182,43 +187,60 @@ def generate_admin_html(request: Request, multi_account_mgr, show_hide_tip: bool
                 status_text = "不可用"
                 status_color = "#f44336"
                 dot_color = "#ff3b30"
-            card_opacity = "1"
+            row_opacity = "1"
             action_buttons = f'''
-                <button onclick="disableAccount('{config.account_id}')" class="disable-btn" title="禁用账户">禁用</button>
-                <button onclick="deleteAccount('{config.account_id}')" class="delete-btn" title="删除账户">删除</button>
+                <button onclick="disableAccount('{config.account_id}')" class="btn-sm btn-disable" title="禁用">禁用</button>
+                <button onclick="deleteAccount('{config.account_id}')" class="btn-sm btn-delete" title="删除">删除</button>
             '''
 
-        # 构建卡片内容
-        accounts_html += f"""
-        <div class="card account-card" style="opacity: {card_opacity}; background: {'#f5f5f5' if float(card_opacity) < 1 else '#fafaf9'};">
-            <div class="acc-header">
-                <div class="acc-title">
-                    <span class="status-dot" style="background-color: {dot_color};"></span>
-                    <span>{config.account_id}</span>
-                </div>
-                <span class="acc-status" style="color: {status_color};">{status_text}</span>
-            </div>
-            <div class="acc-actions">
-                {action_buttons}
-            </div>
-            <div class="acc-body">
-                <div class="acc-row">
-                    <span>过期时间</span>
-                    <span class="font-mono">{config.expires_at or '未设置'}</span>
-                </div>
-                <div class="acc-row">
-                    <span>剩余时长</span>
-                    <span style="color: {status_color};">{expire_display}</span>
-                </div>
-                <div class="acc-row">
-                    <span>累计对话</span>
-                    <span style="color: #2563eb; font-weight: 600;">{account_manager.conversation_count} 次</span>
-                </div>
-                {'<div class="acc-row cooldown-row"><span>冷却倒计时</span><span class="cooldown-text" style="color: ' + status_color + ';">' + str(cooldown_seconds) + '秒 (' + cooldown_reason + ')</span></div>' if cooldown_seconds > 0 else ''}
-            </div>
-        </div>
+        # 构建表格行
+        accounts_rows += f"""
+            <tr style="opacity: {row_opacity};">
+                <td data-label="账号ID">
+                    <div style="display: flex; align-items: center; gap: 8px;">
+                        <span class="status-dot" style="background-color: {dot_color};"></span>
+                        <span style="font-weight: 600;">{config.account_id}</span>
+                    </div>
+                </td>
+                <td data-label="状态">
+                    <span style="color: {status_color}; font-weight: 600; font-size: 12px;">{status_text}</span>
+                </td>
+                <td data-label="过期时间">
+                    <span class="font-mono" style="font-size: 11px; color: #6b6b6b;">{config.expires_at or '未设置'}</span>
+                </td>
+                <td data-label="剩余时长">
+                    <span style="color: {status_color}; font-weight: 500; font-size: 12px;">{expire_display}</span>
+                </td>
+                <td data-label="累计对话">
+                    <span style="color: #2563eb; font-weight: 600;">{account_manager.conversation_count}</span>
+                </td>
+                <td data-label="操作">
+                    <div style="display: flex; gap: 6px;">
+                        {action_buttons}
+                    </div>
+                </td>
+            </tr>
         """
 
+    # 构建完整的账户表格HTML
+    accounts_html = f"""
+        <table class="account-table">
+            <thead>
+                <tr>
+                    <th>账号ID</th>
+                    <th>状态</th>
+                    <th>过期时间</th>
+                    <th>剩余时长</th>
+                    <th>累计对话</th>
+                    <th style="text-align: center;">操作</th>
+                </tr>
+            </thead>
+            <tbody>
+                {accounts_rows if accounts_rows else '<tr><td colspan="6" style="text-align: center; color: #6b6b6b; padding: 24px;">暂无账户</td></tr>'}
+            </tbody>
+        </table>
+    """
+
     # --- 3. 构建 HTML ---
     html_content = f"""
     <!DOCTYPE html>
@@ -326,7 +348,6 @@ def generate_admin_html(request: Request, multi_account_mgr, show_hide_tip: bool
             }}
             .grid-3 {{ display: grid; grid-template-columns: repeat(3, 1fr); gap: 16px; align-items: start; }}
             .grid-env {{ display: grid; grid-template-columns: 1fr 1fr; gap: 16px; align-items: start; }}
-            .account-grid {{ display: grid; grid-template-columns: repeat(auto-fill, minmax(260px, 1fr)); gap: 12px; }}
             .stack-col {{ display: flex; flex-direction: column; gap: 16px; }}
 
             /* Cards */
@@ -349,67 +370,124 @@ def generate_admin_html(request: Request, multi_account_mgr, show_hide_tip: bool
                 letter-spacing: 0.5px;
             }}
 
-            /* Account & Env Styles */
-            .account-card .acc-header {{ display: flex; justify-content: space-between; align-items: center; margin-bottom: 12px; padding-bottom: 12px; border-bottom: 1px solid #f5f5f5; }}
-            .acc-title {{ font-weight: 600; font-size: 14px; display: flex; align-items: center; gap: 8px; overflow: hidden; }}
-            .acc-title span:last-child {{ overflow: hidden; text-overflow: ellipsis; white-space: nowrap; max-width: 120px; }}
-            .status-dot {{ width: 8px; height: 8px; border-radius: 50%; flex-shrink: 0; }}
-            .acc-status {{ font-size: 12px; font-weight: 600; }}
-            .acc-actions {{ display: flex; gap: 8px; margin-bottom: 12px; padding-bottom: 12px; border-bottom: 1px solid #f5f5f5; }}
-            .acc-body {{ }}
-            .acc-row {{ display: flex; justify-content: space-between; font-size: 12px; margin-top: 6px; color: var(--text-sec); }}
-            .cooldown-row {{ background: #fff8e6; padding: 8px; border-radius: 6px; margin-top: 8px; }}
-            .cooldown-text {{ color: #f59e0b; font-weight: 600; }}
-
-            /* Delete Button */
-            .delete-btn {{
+            /* Account Table */
+            .account-table {{
+                width: 100%;
+                border-collapse: collapse;
                 background: #fff;
-                color: #dc2626;
-                border: 1px solid #fecaca;
-                padding: 4px 12px;
+                border: 1px solid #e5e5e5;
+                border-radius: 12px;
+                overflow: hidden;
+            }}
+            .account-table thead {{
+                background: #fafaf9;
+                border-bottom: 2px solid #e5e5e5;
+            }}
+            .account-table th {{
+                padding: 12px 16px;
+                text-align: left;
+                font-size: 12px;
+                font-weight: 600;
+                color: #6b6b6b;
+                text-transform: uppercase;
+                letter-spacing: 0.5px;
+            }}
+            .account-table tbody tr {{
+                border-bottom: 1px solid #f5f5f5;
+                transition: background 0.15s ease;
+            }}
+            .account-table tbody tr:last-child {{
+                border-bottom: none;
+            }}
+            .account-table tbody tr:hover {{
+                background: #fafaf9;
+            }}
+            .account-table td {{
+                padding: 14px 16px;
+                font-size: 13px;
+                color: var(--text-main);
+                vertical-align: middle;
+            }}
+            .status-dot {{
+                width: 8px;
+                height: 8px;
+                border-radius: 50%;
+                flex-shrink: 0;
+            }}
+
+            /* Tabs Navigation */
+            .tabs-nav {{
+                display: flex;
+                gap: 4px;
+                border-bottom: 1px solid #e5e5e5;
+                margin-bottom: 24px;
+                padding: 0 4px;
+            }}
+            .tab-button {{
+                padding: 12px 20px;
+                background: none;
+                border: none;
+                font-size: 14px;
+                font-weight: 500;
+                color: #6b6b6b;
+                cursor: pointer;
+                transition: all 0.2s;
+                border-bottom: 2px solid transparent;
+                position: relative;
+                top: 1px;
+            }}
+            .tab-button:hover {{
+                color: #1d1d1f;
+                background: #f5f5f5;
+            }}
+            .tab-button.active {{
+                color: #0071e3;
+                border-bottom-color: #0071e3;
+                font-weight: 600;
+            }}
+            .tab-content {{
+                display: none;
+            }}
+            .tab-content.active {{
+                display: block;
+            }}
+
+            /* Small Buttons for Table */
+            .btn-sm {{
+                padding: 4px 10px;
                 border-radius: 6px;
                 font-size: 11px;
                 cursor: pointer;
                 font-weight: 500;
                 transition: all 0.2s;
+                border: 1px solid;
             }}
-            .delete-btn:hover {{
+            .btn-delete {{
+                background: #fff;
+                color: #dc2626;
+                border-color: #fecaca;
+            }}
+            .btn-delete:hover {{
                 background: #dc2626;
                 color: white;
                 border-color: #dc2626;
             }}
-
-            /* Disable Button */
-            .disable-btn {{
+            .btn-disable {{
                 background: #fff;
                 color: #f59e0b;
-                border: 1px solid #fed7aa;
-                padding: 4px 12px;
-                border-radius: 6px;
-                font-size: 11px;
-                cursor: pointer;
-                font-weight: 500;
-                transition: all 0.2s;
+                border-color: #fed7aa;
             }}
-            .disable-btn:hover {{
+            .btn-disable:hover {{
                 background: #f59e0b;
                 color: white;
                 border-color: #f59e0b;
             }}
-
-            /* Enable Button */
-            .enable-btn {{
+            .btn-enable {{
                 background: #fff;
                 color: #10b981;
-                border: 1px solid #a7f3d0;
-                padding: 4px 12px;
-                border-radius: 6px;
-                font-size: 11px;
-                cursor: pointer;
-                font-weight: 500;
-                transition: all 0.2s;
+                border-color: #a7f3d0;
             }}
-            .enable-btn:hover {{
+            .btn-enable:hover {{
                 background: #10b981;
                 color: white;
                 border-color: #10b981;
@@ -565,10 +643,18 @@ def generate_admin_html(request: Request, multi_account_mgr, show_hide_tip: bool
             .info-box-title {{ font-weight: 600; font-size: 12px; color: #1d1d1f; margin-bottom: 6px; }}
             .info-box-text {{ font-size: 12px; color: #86868b; line-height: 1.5; }}
 
-            .ep-table {{ width: 100%; border-collapse: collapse; font-size: 13px; }}
+            .ep-table {{
+                width: 100%;
+                border-collapse: collapse;
+                font-size: 13px;
+                background: #fff;
+                border: 1px solid #e5e5e5;
+                border-radius: 12px;
+                overflow: hidden;
+            }}
             .ep-table tr {{ border-bottom: 1px solid #f5f5f5; }}
             .ep-table tr:last-child {{ border-bottom: none; }}
-            .ep-table td {{ padding: 10px 0; vertical-align: middle; }}
+            .ep-table td {{ padding: 12px 16px; vertical-align: middle; }}
 
             .method {{
                 display: inline-block;
@@ -605,6 +691,116 @@ def generate_admin_html(request: Request, multi_account_mgr, show_hide_tip: bool
                 .header-actions .btn {{ justify-content: center; text-align: center; }}
                 .ep-table td {{ display: flex; flex-direction: column; align-items: flex-start; gap: 4px; }}
                 .ep-desc {{ margin-left: 0; }}
+
+                /* Tabs Mobile */
+                .tabs-nav {{
+                    overflow-x: auto;
+                    padding: 0;
+                    gap: 0;
+                    -webkit-overflow-scrolling: touch;
+                }}
+                .tab-button {{
+                    flex: 1;
+                    min-width: 100px;
+                    padding: 10px 16px;
+                    font-size: 13px;
+                }}
+
+                /* Account Table Mobile - Card Layout */
+                .account-table {{
+                    display: block;
+                    border: none;
+                }}
+                .account-table thead {{
+                    display: none;
+                }}
+                .account-table tbody {{
+                    display: block;
+                }}
+                .account-table tr {{
+                    display: block;
+                    margin-bottom: 12px;
+                    border: 1px solid #e5e5e5;
+                    border-radius: 10px;
+                    background: #fff;
+                    padding: 12px;
+                    position: relative;
+                }}
+                .account-table td {{
+                    display: block;
+                    padding: 0;
+                    border: none;
+                }}
+
+                /* 账号ID - 卡片头部 */
+                .account-table td:nth-child(1) {{
+                    margin-bottom: 10px;
+                    padding-bottom: 10px;
+                    padding-right: 80px;
+                    border-bottom: 1px solid #f5f5f5;
+                }}
+                .account-table td:nth-child(1) > div {{
+                    width: 100%;
+                }}
+                .account-table td:nth-child(1) span:last-child {{
+                    word-break: break-all;
+                }}
+
+                /* 状态 - 右上角显示 */
+                .account-table td:nth-child(2) {{
+                    position: absolute;
+                    top: 12px;
+                    right: 12px;
+                    padding: 0;
+                }}
+                .account-table td:nth-child(2)::before {{
+                    display: none;
+                }}
+                .account-table td:nth-child(2) > span {{
+                    display: inline-block;
+                    padding: 4px 10px;
+                    border-radius: 6px;
+                    font-size: 11px;
+                    white-space: nowrap;
+                    font-weight: 600;
+                    background: rgba(255,255,255,0.95);
+                    border: 1px solid currentColor;
+                    opacity: 0.9;
+                }}
+
+                /* 信息行 - 紧凑布局 */
+                .account-table td:nth-child(3),
+                .account-table td:nth-child(4),
+                .account-table td:nth-child(5) {{
+                    display: flex;
+                    justify-content: space-between;
+                    align-items: center;
+                    padding: 6px 0;
+                    font-size: 12px;
+                }}
+                .account-table td:nth-child(3)::before,
+                .account-table td:nth-child(4)::before,
+                .account-table td:nth-child(5)::before {{
+                    content: attr(data-label);
+                    font-weight: 600;
+                    color: #86868b;
+                    font-size: 11px;
+                    margin-right: 8px;
+                }}
+
+                /* 操作按钮 - 底部 */
+                .account-table td:nth-child(6) {{
+                    margin-top: 10px;
+                    padding-top: 10px;
+                    border-top: 1px solid #f5f5f5;
+                }}
+                .account-table td:nth-child(6)::before {{
+                    display: none;
+                }}
+                .account-table td:nth-child(6) > div {{
+                    width: 100%;
+                    justify-content: flex-end;
+                }}
             }}
         </style>
     </head>
@@ -618,35 +814,133 @@ def generate_admin_html(request: Request, multi_account_mgr, show_hide_tip: bool
                 <div class="header-actions">
                     <a href="/public/uptime/html" class="btn" target="_blank">📊 状态监控</a>
                     <a href="/public/log/html" class="btn" target="_blank">📄 公开日志</a>
-                    <a href="/{main.PATH_PREFIX}/admin/log/html?key={main.ADMIN_KEY}" class="btn" target="_blank">🔧 管理日志</a>
+                    <a href="/{admin_path_segment}/log/html" class="btn" target="_blank">🔧 管理日志</a>
                     <button class="btn" onclick="document.getElementById('fileInput').click()">📥 批量上传</button>
                     <input type="file" id="fileInput" accept=".json" multiple style="display:none" onchange="handleFileUpload(event)">
                     <button class="btn" onclick="showEditConfig()" id="edit-btn">✏️ 编辑配置</button>
                 </div>
             </div>
 
-            {hide_tip}
-            {api_key_status}
-            {error_alert}
-            {api_info_tip}
+            <!-- Tabs Navigation -->
+            <div class="tabs-nav">
+                <button class="tab-button active" onclick="switchTab('accounts')">📋 账户管理</button>
+                <button class="tab-button" onclick="switchTab('api')">📚 API文档</button>
+                <button class="tab-button" onclick="switchTab('config')">⚙️ 系统配置</button>
+            </div>
+
+            <!-- Tab 1: 账户管理 -->
+            <div id="tab-accounts" class="tab-content active">
+                {api_key_status}
+                {error_alert}
+                {api_info_tip}
 
-            <div class="section">
-                <div class="section-title">账户状态 ({len(multi_account_mgr.accounts)} 个)</div>
-                <div style="color: #6b6b6b; font-size: 12px; margin-bottom: 12px; padding-left: 4px;">
-                    过期时间为12小时，可以自行修改时间，脚本可能有误差。<br>
-                    批量上传格式：<code style="font-size: 11px;">[{{"secure_c_ses": "...", "csesidx": "...", "config_id": "...", "id": "account_1"}}]</code>（id 可选）
+                <div class="section">
+                    <div class="section-title">账户状态 ({len(multi_account_mgr.accounts)} 个)</div>
+                    <div style="color: #6b6b6b; font-size: 12px; margin-bottom: 12px; padding-left: 4px;">
+                        默认过期时间12小时，注意北京时间 • 批量上传使用 <code style="font-size: 11px; background: rgba(0,0,0,0.05); padding: 2px 6px; border-radius: 4px;">script/download-config.js</code> 油猴脚本
+                    </div>
+                    {accounts_html}
                 </div>
-                <div class="account-grid">
-                    {accounts_html if accounts_html else '<div class="card"><p style="color: #6b6b6b; font-size: 14px; text-align:center;">暂无账户</p></div>'}
+            </div>
+
+            <!-- Tab 2: API文档 -->
+            <div id="tab-api" class="tab-content">
+                <div class="section">
+                    <div class="section-title">API 端点列表</div>
+
+                    <div class="current-url-row">
+                        <span style="font-size:12px; font-weight:600; color:#0071e3; margin-right:8px;">当前页面:</span>
+                        <code style="background:none; padding:0; color:#1d1d1f;">{current_url}</code>
+                    </div>
+
+                    <table class="ep-table">
+                        <tr>
+                            <td width="70"><span class="method m-post">POST</span></td>
+                            <td><span class="ep-path">/{api_path_segment}v1/chat/completions</span></td>
+                            <td><span class="ep-desc">OpenAI 兼容对话接口</span></td>
+                        </tr>
+                        <tr>
+                            <td><span class="method m-get">GET</span></td>
+                            <td><span class="ep-path">/{api_path_segment}v1/models</span></td>
+                            <td><span class="ep-desc">获取模型列表</span></td>
+                        </tr>
+                        <tr>
+                            <td><span class="method m-get">GET</span></td>
+                            <td><span class="ep-path">/{admin_path_segment}</span></td>
+                            <td><span class="ep-desc">管理首页 (需登录)</span></td>
+                        </tr>
+                        <tr>
+                            <td><span class="method m-get">GET</span></td>
+                            <td><span class="ep-path">/{admin_path_segment}/health</span></td>
+                            <td><span class="ep-desc">健康检查 (需登录)</span></td>
+                        </tr>
+                        <tr>
+                            <td><span class="method m-get">GET</span></td>
+                            <td><span class="ep-path">/{admin_path_segment}/accounts</span></td>
+                            <td><span class="ep-desc">账户状态 JSON (需登录)</span></td>
+                        </tr>
+                        <tr>
+                            <td><span class="method m-get">GET</span></td>
+                            <td><span class="ep-path">/{admin_path_segment}/log</span></td>
+                            <td><span class="ep-desc">获取日志 JSON (需登录)</span></td>
+                        </tr>
+                        <tr>
+                            <td><span class="method m-get">GET</span></td>
+                            <td><span class="ep-path">/{admin_path_segment}/log/html</span></td>
+                            <td><span class="ep-desc">日志查看器 HTML (需登录)</span></td>
+                        </tr>
+                        <tr>
+                            <td><span class="method m-del">DEL</span></td>
+                            <td><span class="ep-path">/{admin_path_segment}/log?confirm=yes</span></td>
+                            <td><span class="ep-desc">清空系统日志 (需登录)</span></td>
+                        </tr>
+                        <tr>
+                            <td><span class="method m-get">GET</span></td>
+                            <td><span class="ep-path">/public/stats</span></td>
+                            <td><span class="ep-desc">公开统计数据</span></td>
+                        </tr>
+                        <tr>
+                            <td><span class="method m-get">GET</span></td>
+                            <td><span class="ep-path">/public/log</span></td>
+                            <td><span class="ep-desc">公开日志 (JSON, 脱敏)</span></td>
+                        </tr>
+                        <tr>
+                            <td><span class="method m-get">GET</span></td>
+                            <td><span class="ep-path">/public/log/html</span></td>
+                            <td><span class="ep-desc">公开日志查看器 (HTML)</span></td>
+                        </tr>
+                        <tr>
+                            <td><span class="method m-get">GET</span></td>
+                            <td><span class="ep-path">/public/uptime</span></td>
+                            <td><span class="ep-desc">实时状态监控 (JSON)</span></td>
+                        </tr>
+                        <tr>
+                            <td><span class="method m-get">GET</span></td>
+                            <td><span class="ep-path">/public/uptime/html</span></td>
+                            <td><span class="ep-desc">实时状态监控页面 (HTML)</span></td>
+                        </tr>
+                        <tr>
+                            <td><span class="method m-get">GET</span></td>
+                            <td><span class="ep-path">/docs</span></td>
+                            <td><span class="ep-desc">Swagger API 文档</span></td>
+                        </tr>
+                        <tr>
+                            <td><span class="method m-get">GET</span></td>
+                            <td><span class="ep-path">/redoc</span></td>
+                            <td><span class="ep-desc">ReDoc API 文档</span></td>
+                        </tr>
+                    </table>
                 </div>
             </div>
 
-            <div class="section">
-                <div class="section-title">环境变量配置</div>
-                <div class="grid-env">
-                    <div class="stack-col">
-                        <div class="card">
-                            <h3>必需变量 <span class="badge badge-required">REQUIRED</span></h3>
+            <!-- Tab 3: 系统配置 -->
+            <div id="tab-config" class="tab-content">
+                <div class="section">
+                    <div class="section-title">环境变量配置</div>
+                    <div class="grid-env">
+                        <div class="stack-col">
+                            <div class="card">
+                                <h3>必需变量 <span class="badge badge-required">REQUIRED</span></h3>
                             <div style="margin-top: 12px;">
                                 <div class="env-var">
                                     <div><div class="env-name">ACCOUNTS_CONFIG</div><div class="env-desc">JSON格式账户列表</div></div>
@@ -720,18 +1014,13 @@ def generate_admin_html(request: Request, multi_account_mgr, show_hide_tip: bool
                                 <div><div class="env-name">MODEL_NAME</div><div class="env-desc">模型名称（公开）</div></div>
                                 <div class="env-value">{main.MODEL_NAME}</div>
                             </div>
-                            <div class="env-var">
-                                <div><div class="env-name">HIDE_HOME_PAGE</div><div class="env-desc">隐藏首页管理面板</div></div>
-                                <div class="env-value">{'已隐藏' if main.HIDE_HOME_PAGE else '未隐藏'}</div>
-                            </div>
                         </div>
                     </div>
                 </div>
             </div>
 
-            <div class="section">
-                <div class="section-title">服务信息</div>
-                <div class="grid-3">
+                <div class="section">
+                    <div class="section-title">服务信息</div>
                     <div class="card">
                         <h3>支持的模型</h3>
                         <div class="model-grid">
@@ -751,93 +1040,6 @@ def generate_admin_html(request: Request, multi_account_mgr, show_hide_tip: bool
                             </div>
                         </div>
                     </div>
-
-                    <div class="card" style="grid-column: span 2;">
-                        <h3>API 端点</h3>
-
-                        <div class="current-url-row">
-                            <span style="font-size:12px; font-weight:600; color:#0071e3; margin-right:8px;">当前页面:</span>
-                            <code style="background:none; padding:0; color:#1d1d1f;">{current_url}</code>
-                        </div>
-
-                        <table class="ep-table">
-                            <tr>
-                                <td width="70"><span class="method m-post">POST</span></td>
-                                <td><span class="ep-path">/{main.PATH_PREFIX}/v1/chat/completions</span></td>
-                                <td><span class="ep-desc">OpenAI 兼容对话接口</span></td>
-                            </tr>
-                            <tr>
-                                <td><span class="method m-get">GET</span></td>
-                                <td><span class="ep-path">/{main.PATH_PREFIX}/v1/models</span></td>
-                                <td><span class="ep-desc">获取模型列表</span></td>
-                            </tr>
-                            <tr>
-                                <td><span class="method m-get">GET</span></td>
-                                <td><span class="ep-path">/{main.PATH_PREFIX}/admin</span></td>
-                                <td><span class="ep-desc">管理首页</span></td>
-                            </tr>
-                            <tr>
-                                <td><span class="method m-get">GET</span></td>
-                                <td><span class="ep-path">/{main.PATH_PREFIX}/admin/health?key={{main.ADMIN_KEY}}</span></td>
-                                <td><span class="ep-desc">健康检查 (需 Key)</span></td>
-                            </tr>
-                            <tr>
-                                <td><span class="method m-get">GET</span></td>
-                                <td><span class="ep-path">/{main.PATH_PREFIX}/admin/accounts?key={{main.ADMIN_KEY}}</span></td>
-                                <td><span class="ep-desc">账户状态 JSON (需 Key)</span></td>
-                            </tr>
-                            <tr>
-                                <td><span class="method m-get">GET</span></td>
-                                <td><span class="ep-path">/{main.PATH_PREFIX}/admin/log?key={{main.ADMIN_KEY}}</span></td>
-                                <td><span class="ep-desc">获取日志 JSON (需 Key)</span></td>
-                            </tr>
-                            <tr>
-                                <td><span class="method m-get">GET</span></td>
-                                <td><span class="ep-path">/{main.PATH_PREFIX}/admin/log/html?key={{main.ADMIN_KEY}}</span></td>
-                                <td><span class="ep-desc">日志查看器 HTML (需 Key)</span></td>
-                            </tr>
-                            <tr>
-                                <td><span class="method m-del">DEL</span></td>
-                                <td><span class="ep-path">/{main.PATH_PREFIX}/admin/log?confirm=yes&key={{main.ADMIN_KEY}}</span></td>
-                                <td><span class="ep-desc">清空系统日志 (需 Key)</span></td>
-                            </tr>
-                            <tr>
-                                <td><span class="method m-get">GET</span></td>
-                                <td><span class="ep-path">/public/stats</span></td>
-                                <td><span class="ep-desc">公开统计数据</span></td>
-                            </tr>
-                            <tr>
-                                <td><span class="method m-get">GET</span></td>
-                                <td><span class="ep-path">/public/log</span></td>
-                                <td><span class="ep-desc">公开日志 (JSON, 脱敏)</span></td>
-                            </tr>
-                            <tr>
-                                <td><span class="method m-get">GET</span></td>
-                                <td><span class="ep-path">/public/log/html</span></td>
-                                <td><span class="ep-desc">公开日志查看器 (HTML)</span></td>
-                            </tr>
-                            <tr>
-                                <td><span class="method m-get">GET</span></td>
-                                <td><span class="ep-path">/public/uptime</span></td>
-                                <td><span class="ep-desc">实时状态监控 (JSON)</span></td>
-                            </tr>
-                            <tr>
-                                <td><span class="method m-get">GET</span></td>
-                                <td><span class="ep-path">/public/uptime/html</span></td>
-                                <td><span class="ep-desc">实时状态监控页面 (HTML)</span></td>
-                            </tr>
-                            <tr>
-                                <td><span class="method m-get">GET</span></td>
-                                <td><span class="ep-path">/docs</span></td>
-                                <td><span class="ep-desc">Swagger API 文档</span></td>
-                            </tr>
-                            <tr>
-                                <td><span class="method m-get">GET</span></td>
-                                <td><span class="ep-path">/redoc</span></td>
-                                <td><span class="ep-desc">ReDoc API 文档</span></td>
-                            </tr>
-                        </table>
-                    </div>
                 </div>
             </div>
         </div>
@@ -868,9 +1070,26 @@ def generate_admin_html(request: Request, multi_account_mgr, show_hide_tip: bool
         <script>
             let currentConfig = null;
 
+            // 标签页切换函数
+            function switchTab(tabName) {{
+                // 隐藏所有标签页内容
+                document.querySelectorAll('.tab-content').forEach(content => {{
+                    content.classList.remove('active');
+                }});
+                // 移除所有标签按钮的active状态
+                document.querySelectorAll('.tab-button').forEach(button => {{
+                    button.classList.remove('active');
+                }});
+
+                // 显示选中的标签页
+                document.getElementById('tab-' + tabName).classList.add('active');
+                // 激活对应的按钮
+                event.target.classList.add('active');
+            }}
+
             // 统一的页面刷新函数（避免缓存）
             function refreshPage() {{
-                window.location.href = window.location.pathname + '?t=' + Date.now();
+                window.location.reload();
             }}
 
             // 统一的错误处理函数
@@ -890,7 +1109,7 @@ def generate_admin_html(request: Request, multi_account_mgr, show_hide_tip: bool
             }}
 
             async function showEditConfig() {{
-                const config = await fetch('/{main.PATH_PREFIX}/admin/accounts-config?key={main.ADMIN_KEY}').then(r => r.json());
+                const config = await fetch('/{admin_path_segment}/accounts-config').then(r => r.json());
                 currentConfig = config.accounts;
                 const json = JSON.stringify(config.accounts, null, 2);
                 document.getElementById('jsonEditor').value = json;
@@ -937,16 +1156,15 @@ def generate_admin_html(request: Request, multi_account_mgr, show_hide_tip: bool
 
                 try {{
                     const data = JSON.parse(newJson);
-                    const response = await fetch('/{main.PATH_PREFIX}/admin/accounts-config?key={main.ADMIN_KEY}', {{
+                    const response = await fetch('/{admin_path_segment}/accounts-config', {{
                         method: 'PUT',
                         headers: {{'Content-Type': 'application/json'}},
                         body: JSON.stringify(data)
                     }});
 
-                    const result = await handleApiResponse(response);
-                    alert(`配置已更新！\\n当前账户数: ${{result.account_count}}`);
+                    await handleApiResponse(response);
                     closeModal();
-                    setTimeout(refreshPage, 1000);
+                    refreshPage();
                 }} catch (error) {{
                     console.error('保存失败:', error);
                     alert('更新失败: ' + error.message);
@@ -957,12 +1175,11 @@ def generate_admin_html(request: Request, multi_account_mgr, show_hide_tip: bool
                 if (!confirm(`确定删除账户 ${{accountId}}？`)) return;
 
                 try {{
-                    const response = await fetch('/{main.PATH_PREFIX}/admin/accounts/' + accountId + '?key={main.ADMIN_KEY}', {{
+                    const response = await fetch('/{admin_path_segment}/accounts/' + accountId, {{
                         method: 'DELETE'
                     }});
 
-                    const result = await handleApiResponse(response);
-                    alert(`账户已删除！\\n剩余账户数: ${{result.account_count}}`);
+                    await handleApiResponse(response);
                     refreshPage();
                 }} catch (error) {{
                     console.error('删除失败:', error);
@@ -971,15 +1188,12 @@ def generate_admin_html(request: Request, multi_account_mgr, show_hide_tip: bool
             }}
 
             async function disableAccount(accountId) {{
-                if (!confirm(`确定禁用账户 ${{accountId}}？`)) return;
-
                 try {{
-                    const response = await fetch('/{main.PATH_PREFIX}/admin/accounts/' + accountId + '/disable?key={main.ADMIN_KEY}', {{
+                    const response = await fetch('/{admin_path_segment}/accounts/' + accountId + '/disable', {{
                         method: 'PUT'
                     }});
 
-                    const result = await handleApiResponse(response);
-                    alert(`账户已禁用！`);
+                    await handleApiResponse(response);
                     refreshPage();
                 }} catch (error) {{
                     console.error('禁用失败:', error);
@@ -988,15 +1202,12 @@ def generate_admin_html(request: Request, multi_account_mgr, show_hide_tip: bool
             }}
 
             async function enableAccount(accountId) {{
-                if (!confirm(`确定启用账户 ${{accountId}}？`)) return;
-
                 try {{
-                    const response = await fetch('/{main.PATH_PREFIX}/admin/accounts/' + accountId + '/enable?key={main.ADMIN_KEY}', {{
+                    const response = await fetch('/{admin_path_segment}/accounts/' + accountId + '/enable', {{
                         method: 'PUT'
                     }});
 
-                    const result = await handleApiResponse(response);
-                    alert(`账户已启用！`);
+                    await handleApiResponse(response);
                     refreshPage();
                 }} catch (error) {{
                     console.error('启用失败:', error);
@@ -1034,7 +1245,7 @@ def generate_admin_html(request: Request, multi_account_mgr, show_hide_tip: bool
 
                 try {{
                     // 获取现有配置
-                    const configResp = await fetch('/{main.PATH_PREFIX}/admin/accounts-config?key={main.ADMIN_KEY}');
+                    const configResp = await fetch('/{admin_path_segment}/accounts-config');
                     const configData = await handleApiResponse(configResp);
                     const existing = configData.accounts || [];
 
@@ -1071,16 +1282,15 @@ def generate_admin_html(request: Request, multi_account_mgr, show_hide_tip: bool
                     }}
 
                     // 保存合并后的配置
-                    const response = await fetch('/{main.PATH_PREFIX}/admin/accounts-config?key={main.ADMIN_KEY}', {{
+                    const response = await fetch('/{admin_path_segment}/accounts-config', {{
                         method: 'PUT',
                         headers: {{'Content-Type': 'application/json'}},
                         body: JSON.stringify(existing)
                     }});
 
-                    const result = await handleApiResponse(response);
-                    alert(`导入完成！\\n新增: ${{added}} 个\\n覆盖: ${{updated}} 个\\n当前账户数: ${{result.account_count}}`);
+                    await handleApiResponse(response);
                     event.target.value = '';
-                    setTimeout(refreshPage, 1000);
+                    refreshPage();
                 }} catch (error) {{
                     console.error('导入失败:', error);
                     alert('导入失败: ' + error.message);
@@ -1101,19 +1311,12 @@ def generate_admin_html(request: Request, multi_account_mgr, show_hide_tip: bool
     return html_content
 
 
-async def admin_logs_html(path_prefix: str, key: str = None, authorization: str = Header(None)):
-    """返回美化的 HTML 日志查看界面"""
-    # 动态导入 main 模块的变量（避免循环依赖）
-    import main
 
-    # 验证路径前缀
-    if path_prefix != main.PATH_PREFIX:
-        raise HTTPException(404, "Not Found")
 
-    # 验证管理员密钥
-    admin_key = key or (authorization.replace("Bearer ", "") if authorization and authorization.startswith("Bearer ") else authorization)
-    if admin_key != main.ADMIN_KEY:
-        raise HTTPException(404, "Not Found")
+async def get_public_logs_html():
+    """公开的脱敏日志查看器"""
+    # 动态导入 main 模块的变量（避免循环依赖）
+    import main
 
     html_content = r"""
     <!DOCTYPE html>
@@ -1121,7 +1324,7 @@ async def admin_logs_html(path_prefix: str, key: str = None, authorization: str
     <head>
         <meta charset="utf-8">
         <meta name="viewport" content="width=device-width, initial-scale=1">
-        <title>日志查看器</title>
+        <title>服务状态</title>
         <style>
             * { margin: 0; padding: 0; box-sizing: border-box; }
             html, body { height: 100%; overflow: hidden; }
@@ -1135,7 +1338,7 @@ async def admin_logs_html(path_prefix: str, key: str = None, authorization: str
             }
             .container {
                 width: 100%;
-                max-width: 1400px;
+                max-width: 1200px;
                 height: calc(100vh - 30px);
                 background: white;
                 border-radius: 16px;
@@ -1144,10 +1347,50 @@ async def admin_logs_html(path_prefix: str, key: str = None, authorization: str
                 display: flex;
                 flex-direction: column;
             }
-            h1 { color: #1a1a1a; font-size: 22px; font-weight: 600; margin-bottom: 20px; text-align: center; }
+            h1 {
+                color: #1a1a1a;
+                font-size: 22px;
+                font-weight: 600;
+                margin-bottom: 20px;
+                display: flex;
+                align-items: center;
+                justify-content: center;
+                gap: 12px;
+            }
+            h1 img {
+                width: 32px;
+                height: 32px;
+                border-radius: 8px;
+            }
+            .info-bar {
+                background: #f9f9f9;
+                border: 1px solid #e5e5e5;
+                border-radius: 8px;
+                padding: 12px 16px;
+                margin-bottom: 16px;
+                display: flex;
+                align-items: center;
+                justify-content: space-between;
+                flex-wrap: wrap;
+                gap: 12px;
+            }
+            .info-item {
+                display: flex;
+                align-items: center;
+                gap: 6px;
+                font-size: 13px;
+                color: #6b6b6b;
+            }
+            .info-item strong { color: #1a1a1a; }
+            .info-item a {
+                color: #1a73e8;
+                text-decoration: none;
+                font-weight: 500;
+            }
+            .info-item a:hover { text-decoration: underline; }
             .stats {
                 display: grid;
-                grid-template-columns: repeat(6, 1fr);
+                grid-template-columns: repeat(4, 1fr);
                 gap: 12px;
                 margin-bottom: 16px;
             }
@@ -1162,43 +1405,6 @@ async def admin_logs_html(path_prefix: str, key: str = None, authorization: str
             .stat:hover { border-color: #d4d4d4; }
             .stat-label { color: #6b6b6b; font-size: 11px; margin-bottom: 4px; }
             .stat-value { color: #1a1a1a; font-size: 18px; font-weight: 600; }
-            .controls {
-                display: flex;
-                gap: 8px;
-                margin-bottom: 16px;
-                flex-wrap: wrap;
-            }
-            .controls input, .controls select, .controls button {
-                padding: 6px 10px;
-                border: 1px solid #e5e5e5;
-                border-radius: 8px;
-                font-size: 13px;
-            }
-            .controls select {
-                appearance: none;
-                -webkit-appearance: none;
-                -moz-appearance: none;
-                background-image: url("data:image/svg+xml,%3Csvg width='12' height='12' viewBox='0 0 12 12' fill='none' xmlns='http://www.w3.org/2000/svg'%3E%3Cpath d='M3 5L6 8L9 5' stroke='%236b6b6b' stroke-width='1.5' stroke-linecap='round'/%3E%3C/svg%3E");
-                background-repeat: no-repeat;
-                background-position: right 12px center;
-                padding-right: 32px;
-            }
-            .controls input[type="text"] { flex: 1; min-width: 150px; }
-            .controls button {
-                background: #1a73e8;
-                color: white;
-                border: none;
-                cursor: pointer;
-                font-weight: 500;
-                transition: background 0.15s ease;
-                display: flex;
-                align-items: center;
-                gap: 6px;
-            }
-            .controls button:hover { background: #1557b0; }
-            .controls button.danger { background: #dc2626; }
-            .controls button.danger:hover { background: #b91c1c; }
-            .controls button svg { flex-shrink: 0; }
             .log-container {
                 flex: 1;
                 background: #fafaf9;
@@ -1209,671 +1415,42 @@ async def admin_logs_html(path_prefix: str, key: str = None, authorization: str
                 scrollbar-width: thin;
                 scrollbar-color: rgba(0,0,0,0.15) transparent;
             }
-            /* Webkit 滚动条样式 - 更窄且不占位 */
-            .log-container::-webkit-scrollbar {
-                width: 4px;
-            }
-            .log-container::-webkit-scrollbar-track {
-                background: transparent;
-            }
+            .log-container::-webkit-scrollbar { width: 4px; }
+            .log-container::-webkit-scrollbar-track { background: transparent; }
             .log-container::-webkit-scrollbar-thumb {
                 background: rgba(0,0,0,0.15);
                 border-radius: 2px;
             }
-            .log-container::-webkit-scrollbar-thumb:hover {
-                background: rgba(0,0,0,0.3);
+            .log-container::-webkit-scrollbar-thumb:hover { background: rgba(0,0,0,0.3); }
+            .log-group {
+                margin-bottom: 8px;
+                border: 1px solid #e5e5e5;
+                border-radius: 8px;
+                background: white;
+            }
+            .log-group-header {
+                padding: 10px 12px;
+                background: #f9f9f9;
+                border-radius: 8px 8px 0 0;
+                cursor: pointer;
+                display: flex;
+                align-items: center;
+                gap: 8px;
+                transition: background 0.15s ease;
             }
+            .log-group-header:hover { background: #f0f0f0; }
+            .log-group-content { padding: 8px; }
             .log-entry {
                 padding: 8px 10px;
                 margin-bottom: 4px;
                 background: white;
-                border-radius: 6px;
                 border: 1px solid #e5e5e5;
-                font-size: 12px;
-                color: #1a1a1a;
+                border-radius: 6px;
                 display: flex;
                 align-items: center;
-                gap: 8px;
-                word-break: break-word;
-            }
-            .log-entry > div:first-child {
-                display: flex;
-                align-items: center;
-                gap: 8px;
-            }
-            .log-message {
-                flex: 1;
-                overflow: hidden;
-                text-overflow: ellipsis;
-            }
-            .log-entry:hover { border-color: #d4d4d4; }
-            .log-time { color: #6b6b6b; }
-            .log-level {
-                display: flex;
-                align-items: center;
-                gap: 4px;
-                padding: 2px 6px;
-                border-radius: 3px;
-                font-size: 10px;
-                font-weight: 600;
-            }
-            .log-level::before {
-                content: '';
-                width: 6px;
-                height: 6px;
-                border-radius: 50%;
-            }
-            .log-level.INFO { background: #e3f2fd; color: #1976d2; }
-            .log-level.INFO::before { background: #1976d2; }
-            .log-level.WARNING { background: #fff3e0; color: #f57c00; }
-            .log-level.WARNING::before { background: #f57c00; }
-            .log-level.ERROR { background: #ffebee; color: #d32f2f; }
-            .log-level.ERROR::before { background: #d32f2f; }
-            .log-level.DEBUG { background: #f3e5f5; color: #7b1fa2; }
-            .log-level.DEBUG::before { background: #7b1fa2; }
-            .log-group {
-                margin-bottom: 8px;
-                border: 1px solid #e5e5e5;
-                border-radius: 8px;
-                background: white;
-            }
-            .log-group-header {
-                padding: 10px 12px;
-                background: #f9f9f9;
-                border-radius: 8px 8px 0 0;
-                cursor: pointer;
-                display: flex;
-                align-items: center;
-                gap: 8px;
-                transition: background 0.15s ease;
-            }
-            .log-group-header:hover {
-                background: #f0f0f0;
-            }
-            .log-group-content {
-                padding: 8px;
-            }
-            .log-group .log-entry {
-                margin-bottom: 4px;
-            }
-            .log-group .log-entry:last-child {
-                margin-bottom: 0;
-            }
-            .toggle-icon {
-                display: inline-block;
-                transition: transform 0.2s ease;
-            }
-            .toggle-icon.collapsed {
-                transform: rotate(-90deg);
-            }
-            @media (max-width: 768px) {
-                body { padding: 0; }
-                .container { padding: 15px; height: 100vh; border-radius: 0; max-width: 100%; }
-                h1 { font-size: 18px; margin-bottom: 12px; }
-                .stats { grid-template-columns: repeat(3, 1fr); gap: 8px; }
-                .stat { padding: 8px; }
-                .controls { gap: 6px; }
-                .controls input, .controls select { min-height: 38px; }
-                .controls select { flex: 0 0 auto; }
-                .controls input[type="text"] { flex: 1 1 auto; min-width: 80px; }
-                .controls input[type="number"] { flex: 0 0 60px; }
-                .controls button { padding: 10px 8px; font-size: 12px; flex: 1 1 22%; justify-content: center; min-height: 38px; }
-                .log-entry {
-                    font-size: 12px;
-                    padding: 10px;
-                    gap: 8px;
-                    flex-direction: column;
-                    align-items: flex-start;
-                }
-                .log-entry > div:first-child {
-                    display: flex;
-                    align-items: center;
-                    gap: 6px;
-                    width: 100%;
-                    flex-wrap: wrap;
-                }
-                .log-time { font-size: 11px; color: #9e9e9e; }
-                .log-level { font-size: 10px; }
-                .log-message {
-                    width: 100%;
-                    white-space: normal;
-                    word-break: break-word;
-                    line-height: 1.5;
-                    margin-top: 4px;
-                }
-            }
-        </style>
-    </head>
-    <body>
-        <div class="container">
-            <h1>Gemini API 日志查看器</h1>
-            <div class="stats">
-                <div class="stat">
-                    <div class="stat-label">总数</div>
-                    <div class="stat-value" id="total-count">-</div>
-                </div>
-                <div class="stat">
-                    <div class="stat-label">对话</div>
-                    <div class="stat-value" id="chat-count">-</div>
-                </div>
-                <div class="stat">
-                    <div class="stat-label">INFO</div>
-                    <div class="stat-value" id="info-count">-</div>
-                </div>
-                <div class="stat">
-                    <div class="stat-label">WARNING</div>
-                    <div class="stat-value" id="warning-count">-</div>
-                </div>
-                <div class="stat">
-                    <div class="stat-label">ERROR</div>
-                    <div class="stat-value" id="error-count">-</div>
-                </div>
-                <div class="stat">
-                    <div class="stat-label">更新</div>
-                    <div class="stat-value" id="last-update" style="font-size: 11px;">-</div>
-                </div>
-            </div>
-            <div class="controls">
-                <select id="level-filter">
-                    <option value="">全部</option>
-                    <option value="INFO">INFO</option>
-                    <option value="WARNING">WARNING</option>
-                    <option value="ERROR">ERROR</option>
-                </select>
-                <input type="text" id="search-input" placeholder="搜索...">
-                <input type="number" id="limit-input" value="1500" min="10" max="3000" step="100" style="width: 80px;">
-                <button onclick="loadLogs()">
-                    <svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2">
-                        <circle cx="11" cy="11" r="8"/><path d="m21 21-4.35-4.35"/>
-                    </svg>
-                    查询
-                </button>
-                <button onclick="exportJSON()">
-                    <svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2">
-                        <path d="M21 15v4a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2v-4"/><polyline points="7 10 12 15 17 10"/><line x1="12" y1="15" x2="12" y2="3"/>
-                    </svg>
-                    导出
-                </button>
-                <button id="auto-refresh-btn" onclick="toggleAutoRefresh()">
-                    <svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2">
-                        <polyline points="23 4 23 10 17 10"/><polyline points="1 20 1 14 7 14"/><path d="M3.51 9a9 9 0 0 1 14.85-3.36L23 10M1 14l4.64 4.36A9 9 0 0 0 20.49 15"/>
-                    </svg>
-                    自动刷新
-                </button>
-                <button onclick="clearAllLogs()" class="danger">
-                    <svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2">
-                        <polyline points="3 6 5 6 21 6"/><path d="M19 6v14a2 2 0 0 1-2 2H7a2 2 0 0 1-2-2V6m3 0V4a2 2 0 0 1 2-2h4a2 2 0 0 1 2 2v2"/>
-                    </svg>
-                    清空
-                </button>
-            </div>
-            <div class="log-container" id="log-container">
-                <div style="color: #6b6b6b;">正在加载...</div>
-            </div>
-        </div>
-        <script>
-            let autoRefreshTimer = null;
-            async function loadLogs() {
-                const level = document.getElementById('level-filter').value;
-                const search = document.getElementById('search-input').value;
-                const limit = document.getElementById('limit-input').value;
-                // 从当前 URL 获取 key 参数
-                const urlParams = new URLSearchParams(window.location.search);
-                const key = urlParams.get('key');
-                // 构建 API URL（使用当前路径的前缀）
-                const pathPrefix = window.location.pathname.split('/')[1];
-                let url = `/${pathPrefix}/admin/log?limit=${limit}`;
-                if (key) url += `&key=${key}`;
-                if (level) url += `&level=${level}`;
-                if (search) url += `&search=${encodeURIComponent(search)}`;
-                try {
-                    const response = await fetch(url);
-                    if (!response.ok) {
-                        throw new Error(`HTTP ${response.status}`);
-                    }
-                    const data = await response.json();
-                    if (data && data.logs) {
-                        displayLogs(data.logs);
-                        updateStats(data.stats);
-                        document.getElementById('last-update').textContent = new Date().toLocaleTimeString('zh-CN', {hour: '2-digit', minute: '2-digit'});
-                    } else {
-                        throw new Error('Invalid data format');
-                    }
-                } catch (error) {
-                    document.getElementById('log-container').innerHTML = '<div class="log-entry ERROR">加载失败: ' + error.message + '</div>';
-                }
-            }
-            function updateStats(stats) {
-                document.getElementById('total-count').textContent = stats.memory.total;
-                document.getElementById('info-count').textContent = stats.memory.by_level.INFO || 0;
-                document.getElementById('warning-count').textContent = stats.memory.by_level.WARNING || 0;
-                const errorCount = document.getElementById('error-count');
-                errorCount.textContent = stats.memory.by_level.ERROR || 0;
-                if (stats.errors && stats.errors.count > 0) errorCount.style.color = '#dc2626';
-                document.getElementById('chat-count').textContent = stats.chat_count || 0;
-            }
-            // 分类颜色配置（提取到外部避免重复定义）
-            const CATEGORY_COLORS = {
-                'SYSTEM': '#9e9e9e',
-                'CONFIG': '#607d8b',
-                'LOG': '#9e9e9e',
-                'AUTH': '#4caf50',
-                'SESSION': '#00bcd4',
-                'FILE': '#ff9800',
-                'CHAT': '#2196f3',
-                'API': '#8bc34a',
-                'CACHE': '#9c27b0',
-                'ACCOUNT': '#f44336',
-                'MULTI': '#673ab7'
-            };
-
-            // 账户颜色配置（提取到外部避免重复定义）
-            const ACCOUNT_COLORS = {
-                'account_1': '#9c27b0',
-                'account_2': '#e91e63',
-                'account_3': '#00bcd4',
-                'account_4': '#4caf50',
-                'account_5': '#ff9800'
-            };
-
-            function getCategoryColor(category) {
-                return CATEGORY_COLORS[category] || '#757575';
-            }
-
-            function getAccountColor(accountId) {
-                return ACCOUNT_COLORS[accountId] || '#757575';
-            }
-
-            function displayLogs(logs) {
-                const container = document.getElementById('log-container');
-                if (logs.length === 0) {
-                    container.innerHTML = '<div class="log-entry">暂无日志</div>';
-                    return;
-                }
-
-                // 按请求ID分组
-                const groups = {};
-                const ungrouped = [];
-
-                logs.forEach(log => {
-                    const msg = escapeHtml(log.message);
-                    const reqMatch = msg.match(/\[req_([a-z0-9]+)\]/);
-
-                    if (reqMatch) {
-                        const reqId = reqMatch[1];
-                        if (!groups[reqId]) {
-                            groups[reqId] = [];
-                        }
-                        groups[reqId].push(log);
-                    } else {
-                        ungrouped.push(log);
-                    }
-                });
-
-                // 渲染分组
-                let html = '';
-
-                // 先渲染未分组的日志
-                ungrouped.forEach(log => {
-                    html += renderLogEntry(log);
-                });
-
-                // 读取折叠状态
-                const foldState = JSON.parse(localStorage.getItem('log-fold-state') || '{}');
-
-                // 按请求ID分组渲染（最新的组在下面）
-                Object.keys(groups).forEach(reqId => {
-                    const groupLogs = groups[reqId];
-                    const firstLog = groupLogs[0];
-                    const lastLog = groupLogs[groupLogs.length - 1];
-
-                    // 判断状态
-                    let status = 'in_progress';
-                    let statusColor = '#ff9800';
-                    let statusText = '进行中';
-
-                    if (lastLog.message.includes('响应完成') || lastLog.message.includes('非流式响应完成')) {
-                        status = 'success';
-                        statusColor = '#4caf50';
-                        statusText = '成功';
-                    } else if (lastLog.level === 'ERROR' || lastLog.message.includes('失败')) {
-                        status = 'error';
-                        statusColor = '#f44336';
-                        statusText = '失败';
-                    } else {
-                        // 检查超时（最后日志超过 5 分钟）
-                        const lastLogTime = new Date(lastLog.time);
-                        const now = new Date();
-                        const diffMinutes = (now - lastLogTime) / 1000 / 60;
-                        if (diffMinutes > 5) {
-                            status = 'timeout';
-                            statusColor = '#ffc107';
-                            statusText = '超时';
-                        }
-                    }
-
-                    // 提取账户ID和模型
-                    const accountMatch = firstLog.message.match(/\[account_(\d+)\]/);
-                    const modelMatch = firstLog.message.match(/收到请求: ([^ ]+)/);
-                    const accountId = accountMatch ? `account_${accountMatch[1]}` : '';
-                    const model = modelMatch ? modelMatch[1] : '';
-
-                    // 检查折叠状态
-                    const isCollapsed = foldState[reqId] === true;
-                    const contentStyle = isCollapsed ? 'style="display: none;"' : '';
-                    const iconClass = isCollapsed ? 'class="toggle-icon collapsed"' : 'class="toggle-icon"';
-
-                    html += `
-                        <div class="log-group" data-req-id="${reqId}">
-                            <div class="log-group-header" onclick="toggleGroup('${reqId}')">
-                                <span style="color: ${statusColor}; font-weight: 600; font-size: 11px;">⬤ ${statusText}</span>
-                                <span style="color: #666; font-size: 11px; margin-left: 8px;">req_${reqId}</span>
-                                ${accountId ? `<span style="color: ${getAccountColor(accountId)}; font-size: 11px; margin-left: 8px;">${accountId}</span>` : ''}
-                                ${model ? `<span style="color: #999; font-size: 11px; margin-left: 8px;">${model}</span>` : ''}
-                                <span style="color: #999; font-size: 11px; margin-left: 8px;">${groupLogs.length}条日志</span>
-                                <span ${iconClass} style="margin-left: auto; color: #999;">▼</span>
-                            </div>
-                            <div class="log-group-content" ${contentStyle}>
-                                ${groupLogs.map(log => renderLogEntry(log)).join('')}
-                            </div>
-                        </div>
-                    `;
-                });
-
-                container.innerHTML = html;
-
-                // 自动滚动到底部，显示最新日志
-                container.scrollTop = container.scrollHeight;
-            }
-
-            function renderLogEntry(log) {
-                const msg = escapeHtml(log.message);
-                let displayMsg = msg;
-                let categoryTags = [];
-                let accountId = null;
-
-                // 解析所有标签：[CATEGORY1] [CATEGORY2] [account_X] [req_X] message
-                let remainingMsg = msg;
-                const tagRegex = /^\[([A-Z_a-z0-9]+)\]/;
-
-                while (true) {
-                    const match = remainingMsg.match(tagRegex);
-                    if (!match) break;
-
-                    const tag = match[1];
-                    remainingMsg = remainingMsg.substring(match[0].length).trim();
-
-                    // 跳过req_标签（已在组头部显示）
-                    if (tag.startsWith('req_')) {
-                        continue;
-                    }
-                    // 判断是否为账户ID
-                    else if (tag.startsWith('account_')) {
-                        accountId = tag;
-                    } else {
-                        // 普通分类标签
-                        categoryTags.push(tag);
-                    }
-                }
-
-                displayMsg = remainingMsg;
-
-                // 生成分类标签HTML
-                const categoryTagsHtml = categoryTags.map(cat =>
-                    `<span class="log-category" style="background: ${getCategoryColor(cat)}; color: white; padding: 2px 6px; border-radius: 3px; font-size: 10px; font-weight: 600; margin-left: 2px;">${cat}</span>`
-                ).join('');
-
-                // 生成账户标签HTML
-                const accountTagHtml = accountId
-                    ? `<span style="color: ${getAccountColor(accountId)}; font-size: 11px; font-weight: 600; margin-left: 2px;">${accountId}</span>`
-                    : '';
-
-                return `
-                    <div class="log-entry ${log.level}">
-                        <div>
-                            <span class="log-time">${log.time}</span>
-                            <span class="log-level ${log.level}">${log.level}</span>
-                            ${categoryTagsHtml}
-                            ${accountTagHtml}
-                        </div>
-                        <div class="log-message">${displayMsg}</div>
-                    </div>
-                `;
-            }
-
-            function toggleGroup(reqId) {
-                const group = document.querySelector(`.log-group[data-req-id="${reqId}"]`);
-                const content = group.querySelector('.log-group-content');
-                const icon = group.querySelector('.toggle-icon');
-
-                const isCollapsed = content.style.display === 'none';
-                if (isCollapsed) {
-                    content.style.display = 'block';
-                    icon.classList.remove('collapsed');
-                } else {
-                    content.style.display = 'none';
-                    icon.classList.add('collapsed');
-                }
-
-                // 保存折叠状态到 localStorage
-                const foldState = JSON.parse(localStorage.getItem('log-fold-state') || '{}');
-                foldState[reqId] = !isCollapsed;
-                localStorage.setItem('log-fold-state', JSON.stringify(foldState));
-            }
-            function escapeHtml(text) {
-                const div = document.createElement('div');
-                div.textContent = text;
-                return div.innerHTML;
-            }
-            async function exportJSON() {
-                try {
-                    const urlParams = new URLSearchParams(window.location.search);
-                    const key = urlParams.get('key');
-                    const pathPrefix = window.location.pathname.split('/')[1];
-                    let url = `/${pathPrefix}/admin/log?limit=3000`;
-                    if (key) url += `&key=${key}`;
-                    const response = await fetch(url);
-                    const data = await response.json();
-                    const blob = new Blob([JSON.stringify({exported_at: new Date().toISOString(), logs: data.logs}, null, 2)], {type: 'application/json'});
-                    const blobUrl = URL.createObjectURL(blob);
-                    const a = document.createElement('a');
-                    a.href = blobUrl;
-                    a.download = 'logs_' + new Date().toISOString().slice(0, 19).replace(/:/g, '-') + '.json';
-                    a.click();
-                    URL.revokeObjectURL(blobUrl);
-                    alert('导出成功');
-                } catch (error) {
-                    alert('导出失败: ' + error.message);
-                }
-            }
-            async function clearAllLogs() {
-                if (!confirm('确定清空所有日志？')) return;
-                try {
-                    const urlParams = new URLSearchParams(window.location.search);
-                    const key = urlParams.get('key');
-                    const pathPrefix = window.location.pathname.split('/')[1];
-                    let url = `/${pathPrefix}/admin/log?confirm=yes`;
-                    if (key) url += `&key=${key}`;
-                    const response = await fetch(url, {method: 'DELETE'});
-                    if (response.ok) {
-                        alert('已清空');
-                        loadLogs();
-                    } else {
-                        alert('清空失败');
-                    }
-                } catch (error) {
-                    alert('清空失败: ' + error.message);
-                }
-            }
-            let autoRefreshEnabled = true;
-            function toggleAutoRefresh() {
-                autoRefreshEnabled = !autoRefreshEnabled;
-                const btn = document.getElementById('auto-refresh-btn');
-                if (autoRefreshEnabled) {
-                    btn.style.background = '#1a73e8';
-                    autoRefreshTimer = setInterval(loadLogs, 5000);
-                } else {
-                    btn.style.background = '#6b6b6b';
-                    if (autoRefreshTimer) {
-                        clearInterval(autoRefreshTimer);
-                        autoRefreshTimer = null;
-                    }
-                }
-            }
-            document.addEventListener('DOMContentLoaded', () => {
-                loadLogs();
-                autoRefreshTimer = setInterval(loadLogs, 5000);
-                document.getElementById('search-input').addEventListener('keypress', (e) => {
-                    if (e.key === 'Enter') loadLogs();
-                });
-                document.getElementById('level-filter').addEventListener('change', loadLogs);
-                document.getElementById('limit-input').addEventListener('change', loadLogs);
-            });
-        </script>
-    </body>
-    </html>
-    """
-    return HTMLResponse(content=html_content)
-
-
-async def get_public_logs_html():
-    """公开的脱敏日志查看器"""
-    # 动态导入 main 模块的变量（避免循环依赖）
-    import main
-
-    html_content = r"""
-    <!DOCTYPE html>
-    <html>
-    <head>
-        <meta charset="utf-8">
-        <meta name="viewport" content="width=device-width, initial-scale=1">
-        <title>服务状态</title>
-        <style>
-            * { margin: 0; padding: 0; box-sizing: border-box; }
-            html, body { height: 100%; overflow: hidden; }
-            body {
-                font-family: 'Consolas', 'Monaco', monospace;
-                background: #fafaf9;
-                display: flex;
-                align-items: center;
-                justify-content: center;
-                padding: 15px;
-            }
-            .container {
-                width: 100%;
-                max-width: 1200px;
-                height: calc(100vh - 30px);
-                background: white;
-                border-radius: 16px;
-                padding: 30px;
-                box-shadow: 0 2px 8px rgba(0,0,0,0.08);
-                display: flex;
-                flex-direction: column;
-            }
-            h1 {
-                color: #1a1a1a;
-                font-size: 22px;
-                font-weight: 600;
-                margin-bottom: 20px;
-                display: flex;
-                align-items: center;
-                justify-content: center;
-                gap: 12px;
-            }
-            h1 img {
-                width: 32px;
-                height: 32px;
-                border-radius: 8px;
-            }
-            .info-bar {
-                background: #f9f9f9;
-                border: 1px solid #e5e5e5;
-                border-radius: 8px;
-                padding: 12px 16px;
-                margin-bottom: 16px;
-                display: flex;
-                align-items: center;
-                justify-content: space-between;
-                flex-wrap: wrap;
-                gap: 12px;
-            }
-            .info-item {
-                display: flex;
-                align-items: center;
-                gap: 6px;
-                font-size: 13px;
-                color: #6b6b6b;
-            }
-            .info-item strong { color: #1a1a1a; }
-            .info-item a {
-                color: #1a73e8;
-                text-decoration: none;
-                font-weight: 500;
-            }
-            .info-item a:hover { text-decoration: underline; }
-            .stats {
-                display: grid;
-                grid-template-columns: repeat(4, 1fr);
-                gap: 12px;
-                margin-bottom: 16px;
-            }
-            .stat {
-                background: #fafaf9;
-                padding: 12px;
-                border: 1px solid #e5e5e5;
-                border-radius: 8px;
-                text-align: center;
-                transition: all 0.15s ease;
-            }
-            .stat:hover { border-color: #d4d4d4; }
-            .stat-label { color: #6b6b6b; font-size: 11px; margin-bottom: 4px; }
-            .stat-value { color: #1a1a1a; font-size: 18px; font-weight: 600; }
-            .log-container {
-                flex: 1;
-                background: #fafaf9;
-                border: 1px solid #e5e5e5;
-                border-radius: 8px;
-                padding: 12px;
-                overflow-y: auto;
-                scrollbar-width: thin;
-                scrollbar-color: rgba(0,0,0,0.15) transparent;
-            }
-            .log-container::-webkit-scrollbar { width: 4px; }
-            .log-container::-webkit-scrollbar-track { background: transparent; }
-            .log-container::-webkit-scrollbar-thumb {
-                background: rgba(0,0,0,0.15);
-                border-radius: 2px;
-            }
-            .log-container::-webkit-scrollbar-thumb:hover { background: rgba(0,0,0,0.3); }
-            .log-group {
-                margin-bottom: 8px;
-                border: 1px solid #e5e5e5;
-                border-radius: 8px;
-                background: white;
-            }
-            .log-group-header {
-                padding: 10px 12px;
-                background: #f9f9f9;
-                border-radius: 8px 8px 0 0;
-                cursor: pointer;
-                display: flex;
-                align-items: center;
-                gap: 8px;
-                transition: background 0.15s ease;
-            }
-            .log-group-header:hover { background: #f0f0f0; }
-            .log-group-content { padding: 8px; }
-            .log-entry {
-                padding: 8px 10px;
-                margin-bottom: 4px;
-                background: white;
-                border: 1px solid #e5e5e5;
-                border-radius: 6px;
-                display: flex;
-                align-items: center;
-                gap: 10px;
-                font-size: 13px;
-                transition: all 0.15s ease;
+                gap: 10px;
+                font-size: 13px;
+                transition: all 0.15s ease;
             }
             .log-entry:hover { border-color: #d4d4d4; }
             .log-time { color: #6b6b6b; font-size: 12px; min-width: 140px; }
@@ -2379,3 +1956,247 @@ async def get_uptime_html():
     </html>
     """
     return HTMLResponse(content=html_content)
+
+
+async def get_login_html(request: Request, error: str = None) -> HTMLResponse:
+    """生成登录页面"""
+    import main
+
+    # 获取当前URL（用于表单提交）
+    current_path = request.url.path
+
+    # 错误提示
+    error_html = ""
+    if error:
+        error_html = f"""
+        <div class="error-box">
+            ⚠️ {error}
+        </div>
+        """
+
+    html_content = f"""
+    <!DOCTYPE html>
+    <html lang="zh-CN">
+    <head>
+        <meta charset="UTF-8">
+        <meta name="viewport" content="width=device-width, initial-scale=1.0">
+        <title>登录</title>
+        <style>
+            * {{
+                margin: 0;
+                padding: 0;
+                box-sizing: border-box;
+            }}
+
+            body {{
+                font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, sans-serif;
+                background: #fafaf9;
+                min-height: 100vh;
+                display: flex;
+                align-items: center;
+                justify-content: center;
+                padding: 20px;
+            }}
+
+            .container {{
+                background: #fff;
+                border: 1px solid #e5e5e5;
+                border-radius: 12px;
+                width: 100%;
+                max-width: 380px;
+                padding: 40px 32px;
+            }}
+
+            .header {{
+                text-align: center;
+                margin-bottom: 32px;
+            }}
+
+            h1 {{
+                font-size: 22px;
+                font-weight: 600;
+                color: #1d1d1f;
+                margin-bottom: 6px;
+            }}
+
+            .subtitle {{
+                font-size: 14px;
+                color: #86868b;
+            }}
+
+            .error-box {{
+                padding: 12px 14px;
+                background: #fff5f5;
+                border: 1px solid #fecaca;
+                border-radius: 8px;
+                color: #dc2626;
+                font-size: 14px;
+                margin-bottom: 20px;
+            }}
+
+            label {{
+                display: block;
+                font-size: 14px;
+                font-weight: 500;
+                color: #1d1d1f;
+                margin-bottom: 8px;
+            }}
+
+            input[type="password"] {{
+                width: 100%;
+                padding: 12px 14px;
+                border: 1px solid #d4d4d4;
+                border-radius: 8px;
+                font-size: 15px;
+                color: #1d1d1f;
+                background: #fff;
+                transition: border-color 0.15s;
+                outline: none;
+                margin-bottom: 20px;
+            }}
+
+            input[type="password"]:focus {{
+                border-color: #0071e3;
+            }}
+
+            input[type="password"]::placeholder {{
+                color: #c7c7cc;
+            }}
+
+            button {{
+                width: 100%;
+                padding: 12px;
+                background: #0071e3;
+                color: #fff;
+                border: none;
+                border-radius: 8px;
+                font-size: 15px;
+                font-weight: 500;
+                cursor: pointer;
+                transition: background 0.15s;
+            }}
+
+            button:hover {{
+                background: #0077ed;
+            }}
+
+            button:active {{
+                background: #006dd1;
+            }}
+
+            .hint {{
+                margin-top: 20px;
+                padding: 12px;
+                background: #f6f6f8;
+                border-radius: 8px;
+                font-size: 13px;
+                color: #86868b;
+                line-height: 1.5;
+            }}
+
+            @media (max-width: 480px) {{
+                .container {{
+                    padding: 32px 24px;
+                }}
+            }}
+        </style>
+    </head>
+    <body>
+        <div class="container">
+            <div class="header">
+                <h1>管理员登录</h1>
+                <p class="subtitle">Gemini Business API</p>
+            </div>
+
+            {error_html}
+
+            <form method="POST" action="{current_path}">
+                <label for="admin_key">密钥</label>
+                <input
+                    type="password"
+                    id="admin_key"
+                    name="admin_key"
+                    placeholder="输入 ADMIN_KEY"
+                    required
+                    autofocus
+                >
+                <button type="submit">登录</button>
+            </form>
+
+            <div class="hint">
+                会话保持 24 小时
+            </div>
+        </div>
+    </body>
+    </html>
+    """
+    return HTMLResponse(content=html_content)
+
+
+async def admin_logs_html_no_auth(request):
+    """返回美化的 HTML 日志查看界面（无需认证）"""
+    from fastapi.responses import HTMLResponse
+
+    html_content = r"""
+    <!DOCTYPE html>
+    <html>
+    <head>
+        <meta charset="utf-8">
+        <meta name="viewport" content="width=device-width, initial-scale=1">
+        <title>日志查看器</title>
+        <style>
+            * { margin: 0; padding: 0; box-sizing: border-box; }
+            body {
+                font-family: "Consolas", "Monaco", monospace;
+                background: #fafaf9;
+                padding: 20px;
+            }
+            .container {
+                max-width: 1400px;
+                margin: 0 auto;
+                background: white;
+                border-radius: 16px;
+                padding: 30px;
+                box-shadow: 0 2px 8px rgba(0,0,0,0.08);
+            }
+            h1 { color: #1a1a1a; font-size: 22px; margin-bottom: 20px; }
+            .log-item { padding: 10px; border-bottom: 1px solid #e5e5e5; font-size: 12px; }
+            .log-time { color: #6b6b6b; margin-right: 10px; }
+            .log-level { padding: 2px 6px; border-radius: 4px; margin-right: 10px; }
+            .log-level.INFO { background: #e3f2fd; color: #1976d2; }
+            .log-level.WARNING { background: #fff3e0; color: #f57c00; }
+            .log-level.ERROR { background: #ffebee; color: #c62828; }
+        </style>
+    </head>
+    <body>
+        <div class="container">
+            <h1>📋 系统日志</h1>
+            <div id="logs">加载中...</div>
+        </div>
+        <script>
+            async function loadLogs() {
+                try {
+                    const path = window.location.pathname.replace("/log/html", "/log");
+                    const res = await fetch(path);
+                    const data = await res.json();
+                    let html = "";
+                    for (const log of data.logs.reverse()) {
+                        html += `<div class="log-item">
+                            <span class="log-time">${log.time}</span>
+                            <span class="log-level ${log.level}">${log.level}</span>
+                            <span>${log.message}</span>
+                        </div>`;
+                    }
+                    document.getElementById("logs").innerHTML = html || "暂无日志";
+                } catch (e) {
+                    document.getElementById("logs").innerHTML = "加载失败";
+                }
+            }
+            loadLogs();
+            setInterval(loadLogs, 5000);
+        </script>
+    </body>
+    </html>
+    """
+    return HTMLResponse(content=html_content)
+