Upload 23 files

Dockerfile

@@ -1 +1,27 @@
-FROM tomoto6/gate:latest
+FROM python:3.11-slim
+
+RUN apt-get update && apt-get install -y \
+    ffmpeg \
+    curl \
+    && rm -rf /var/lib/apt/lists/*
+
+WORKDIR /app
+
+COPY requirements.txt .
+
+RUN pip install --no-cache-dir -r requirements.txt
+
+COPY . .
+
+RUN mkdir -p /tmp/cache/epg /tmp/cache/meta /app/static
+
+ENV PYTHONUNBUFFERED=1 \
+    CACHE_DIR=/tmp/cache \
+    PYTHONDONTWRITEBYTECODE=1
+
+HEALTHCHECK --interval=30s --timeout=10s --start-period=5s --retries=3 \
+    CMD curl -f http://localhost:7860/health || exit 1
+
+EXPOSE 7860
+
+CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "7860", "--workers", "1", "--log-level", "error"]

app.py

@@ -0,0 +1,1273 @@
+import time
+import json
+import secrets
+import asyncio
+import httpx
+from pathlib import Path
+from datetime import datetime, timedelta
+from fastapi import FastAPI, Request, Header, Depends, HTTPException, status
+from fastapi.responses import JSONResponse, Response, FileResponse, StreamingResponse
+from fastapi.staticfiles import StaticFiles
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.middleware.gzip import GZipMiddleware
+from pydantic import BaseModel
+from typing import Optional, List
+from config import Config
+from cache_manager import cache
+from user_manager import user_manager, User, AVAILABLE_BADGES
+from proxy_handler import (
+    proxy_media, 
+    proxy_live_stream_direct, 
+    proxy_playback_stream,
+    get_live_m3u8_url
+)
+from utils import get_auth, get_channels, get_jst_date, fetch_epg, get_all_epg
+
+app = FastAPI(
+    title=Config.APP_NAME,
+    version=Config.APP_VERSION,
+    description=Config.APP_DESCRIPTION
+)
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+    expose_headers=["Content-Length", "Content-Range", "Accept-Ranges", "Content-Disposition"]
+)
+
+if Config.ENABLE_GZIP:
+    app.add_middleware(GZipMiddleware, minimum_size=1000)
+
+static_path = Path(__file__).parent / "static"
+if static_path.exists():
+    app.mount("/static", StaticFiles(directory=str(static_path)), name="static")
+
+admin_tokens = {}
+
+def create_admin_token() -> str:
+    token = secrets.token_urlsafe(32)
+    expiry = datetime.now() + timedelta(hours=24)
+    admin_tokens[token] = expiry
+    
+    return token
+
+def verify_admin_token(token: str) -> bool:
+    if not token:
+        return False
+    
+    now = datetime.now()
+    expired = [t for t, exp in admin_tokens.items() if exp < now]
+    for t in expired:
+        del admin_tokens[t]
+    
+    if token not in admin_tokens:
+        return False
+    
+    expiry = admin_tokens[token]
+    now = datetime.now()
+    
+    if now > expiry:
+        del admin_tokens[token]
+        return False
+    
+    return True
+
+def get_admin_token(authorization: Optional[str]) -> Optional[str]:
+    if not authorization:
+        return None
+    
+    if authorization.startswith("Bearer "):
+        return authorization[7:]
+    
+    return authorization
+
+def get_current_admin_token(authorization: Optional[str] = Header(None)) -> str:
+    token = get_admin_token(authorization)
+    
+    if not token:
+        raise HTTPException(
+            status_code=status.HTTP_401_UNAUTHORIZED,
+            detail="No token provided"
+        )
+    
+    if not verify_admin_token(token):
+        raise HTTPException(
+            status_code=status.HTTP_401_UNAUTHORIZED,
+            detail="Invalid or expired token"
+        )
+    
+    return token
+
+class PasswordVerify(BaseModel):
+    username: str
+    password_hash: str
+
+class AdminLogin(BaseModel):
+    username: str
+    password_hash: str
+
+class CreateUserRequest(BaseModel):
+    username: str
+    password: Optional[str] = None
+    expires_days: Optional[int] = None
+    notes: str = ""
+    badge: Optional[str] = None
+    is_admin: bool = False
+
+class ExtendExpiryRequest(BaseModel):
+    days: int
+
+class SetBadgeRequest(BaseModel):
+    badge: Optional[str] = None
+
+class UserSettings(BaseModel):
+    favorite_channels: Optional[List[str]] = None
+    playback_history: Optional[dict] = None
+    program_reminders: Optional[List[dict]] = None
+    download_concurrency: Optional[int] = None
+    batch_download_concurrency: Optional[int] = None
+    fab_position: Optional[dict] = None
+    other_settings: Optional[dict] = None
+
+@app.middleware("http")
+async def protocol_middleware(request: Request, call_next):
+    forwarded_proto = request.headers.get('X-Forwarded-Proto', '')
+    forwarded_host = request.headers.get('X-Forwarded-Host', '')
+    forwarded_port = request.headers.get('X-Forwarded-Port', '')
+    
+    if forwarded_proto:
+        request.scope['scheme'] = forwarded_proto
+        
+    if forwarded_host:
+        port = 443 if forwarded_proto == 'https' else 80
+        if forwarded_port:
+            try:
+                port = int(forwarded_port)
+            except:
+                pass
+        request.scope['server'] = (forwarded_host, port)
+    
+    response = await call_next(request)
+    return response
+
+@app.middleware("http")
+async def performance_middleware(request: Request, call_next):
+    start_time = time.time()
+    response = await call_next(request)
+    process_time = int((time.time() - start_time) * 1000)
+    response.headers["X-Response-Time"] = f"{process_time}ms"
+    
+    if request.url.path.startswith('/static/'):
+        response.headers['Cache-Control'] = 'public, max-age=86400'
+    
+    if request.url.path.startswith('/api/') or request.url.path.startswith('/live/') or request.url.path.startswith('/vod/'):
+        response.headers['Access-Control-Allow-Origin'] = '*'
+        response.headers['Access-Control-Allow-Methods'] = 'GET, POST, OPTIONS, DELETE'
+        response.headers['Access-Control-Allow-Headers'] = 'Authorization, Content-Type, Range'
+    
+    return response
+
+@app.get("/")
+async def root():
+    html_path = Path(__file__).parent / "static" / "index.html"
+    if html_path.exists():
+        return FileResponse(html_path)
+    return {"message": "Frontend not found"}
+
+@app.get("/channels")
+async def channels_page():
+    return await root()
+
+@app.get("/player")
+async def player_page():
+    return await root()
+
+@app.get("/epg")
+async def epg_page():
+    return await root()
+
+@app.get("/cache")
+async def cache_page():
+    return await root()
+
+@app.get("/api-test")
+async def api_test_page():
+    return await root()
+
+@app.get("/admin")
+async def admin_page():
+    html_path = Path(__file__).parent / "static" / "admin.html"
+    if html_path.exists():
+        return FileResponse(html_path)
+    return {"message": "Admin page not found"}
+
+@app.get("/admin/login")
+async def admin_login_page():
+    html_path = Path(__file__).parent / "static" / "admin-login.html"
+    if html_path.exists():
+        return FileResponse(html_path)
+    return {"message": "Admin login page not found"}
+
+@app.post("/api/verify-password")
+async def verify_password(data: PasswordVerify):
+    try:
+        # ✅ 检查是否是配置文件中的管理员
+        if (data.username == Config.ADMIN_USERNAME and 
+            data.password_hash == Config.ADMIN_PASSWORD_HASH):
+            
+            return {
+                "success": True, 
+                "message": "Admin login successful",
+                "user": {
+                    "username": data.username,
+                    "is_admin": True,  # ✅ 配置文件管理员
+                    "badge": None
+                }
+            }
+        
+        # ✅ 检查数据库中的用户
+        if data.username and user_manager.verify_user(data.username, data.password_hash):
+            user = user_manager.get_user(data.username)
+            
+            if not user:
+                return {"success": False, "message": "User not found"}
+            
+            user_data = user_manager.get_user_data(data.username)
+            
+            return {
+                "success": True, 
+                "message": "User login successful",
+                "user": {
+                    "username": data.username,
+                    "is_admin": user.is_admin,  # ✅ 从数据库读取 is_admin 字段
+                    "badge": user.badge if user and user.badge else None
+                },
+                "user_data": user_data
+            }
+        
+        return {"success": False, "message": "Invalid username or password"}
+    
+    except Exception as e:
+        return JSONResponse(
+            content={"success": False, "message": str(e)},
+            status_code=500
+        )
+
+@app.get("/api/badges")
+async def get_badges():
+    return {
+        "success": True,
+        "badges": AVAILABLE_BADGES
+    }
+    
+@app.post("/api/admin/login")
+async def admin_login(data: AdminLogin):
+    try:
+        if (data.username == Config.ADMIN_USERNAME and 
+            data.password_hash == Config.ADMIN_PASSWORD_HASH):
+            
+            token = create_admin_token()
+            
+            return {
+                "success": True,
+                "token": token,
+                "message": "Login successful"
+            }
+        else:
+            return JSONResponse(
+                content={"success": False, "message": "Invalid credentials"},
+                status_code=401
+            )
+    except Exception as e:
+        return JSONResponse(
+            content={"success": False, "message": str(e)},
+            status_code=500
+        )
+
+@app.get("/api/admin/check")
+async def admin_check(authorization: Optional[str] = Header(None)):
+    token = get_admin_token(authorization)
+    
+    if token and verify_admin_token(token):
+        return {"authenticated": True}
+    
+    return JSONResponse(
+        content={"authenticated": False},
+        status_code=401
+    )
+
+@app.get("/api/admin/badges")
+async def admin_get_badges(token: str = Depends(get_current_admin_token)):
+    try:
+        return {
+            "success": True,
+            "badges": AVAILABLE_BADGES
+        }
+    except Exception as e:
+        return JSONResponse(
+            content={"success": False, "error": str(e)},
+            status_code=500
+        )
+
+@app.get("/api/admin/stats")
+async def admin_stats(token: str = Depends(get_current_admin_token)):
+    try:
+        stats = user_manager.get_stats()
+        return stats
+    except Exception as e:
+        return JSONResponse(
+            content={"error": str(e)},
+            status_code=500
+        )
+
+@app.get("/api/admin/users")
+async def admin_list_users(token: str = Depends(get_current_admin_token)):
+    try:
+        users = user_manager.list_users()
+        
+        return {
+            "success": True,
+            "count": len(users),
+            "users": [u.dict() for u in users]
+        }
+    except Exception as e:
+        return JSONResponse(
+            content={"success": False, "error": str(e)},
+            status_code=500
+        )
+
+@app.post("/api/admin/users")
+async def admin_create_user(data: CreateUserRequest, token: str = Depends(get_current_admin_token)):
+    try:
+        if len(user_manager.users) >= Config.MAX_USERS:
+            return JSONResponse(
+                content={"error": f"Maximum {Config.MAX_USERS} users allowed"},
+                status_code=400
+            )
+        
+        user, plain_password = user_manager.create_user(
+            username=data.username,
+            password=data.password,
+            expires_days=data.expires_days,
+            notes=data.notes,
+            badge=data.badge,
+            is_admin=data.is_admin
+        )
+        
+        return {
+            "success": True,
+            "user": user.dict(),
+            "password": plain_password
+        }
+    
+    except ValueError as e:
+        return JSONResponse(
+            content={"error": str(e)},
+            status_code=400
+        )
+    except Exception as e:
+        return JSONResponse(
+            content={"error": str(e)},
+            status_code=500
+        )
+
+@app.delete("/api/admin/users/{username}")
+async def admin_delete_user(username: str, token: str = Depends(get_current_admin_token)):
+    if user_manager.delete_user(username):
+        # ✅ 同时删除用户设置
+        user_manager.delete_user_settings(username)
+        return {"success": True, "message": f"User {username} deleted"}
+    
+    return JSONResponse(
+        content={"error": "User not found"},
+        status_code=404
+    )
+
+@app.post("/api/admin/users/{username}/activate")
+async def admin_activate_user(username: str, token: str = Depends(get_current_admin_token)):
+    if user_manager.activate_user(username):
+        return {"success": True, "message": f"User {username} activated"}
+    
+    return JSONResponse(
+        content={"error": "User not found"},
+        status_code=404
+    )
+
+@app.post("/api/admin/users/{username}/deactivate")
+async def admin_deactivate_user(username: str, token: str = Depends(get_current_admin_token)):
+    if user_manager.deactivate_user(username):
+        return {"success": True, "message": f"User {username} deactivated"}
+    
+    return JSONResponse(
+        content={"error": "User not found"},
+        status_code=404
+    )
+
+@app.post("/api/admin/users/{username}/extend")
+async def admin_extend_expiry(username: str, data: ExtendExpiryRequest, token: str = Depends(get_current_admin_token)):
+    if user_manager.extend_expiry(username, data.days):
+        return {
+            "success": True,
+            "message": f"Extended {username} expiry by {data.days} days"
+        }
+    
+    return JSONResponse(
+        content={"error": "User not found"},
+        status_code=404
+    )
+
+@app.post("/api/admin/users/{username}/badge")
+async def admin_set_badge(username: str, data: SetBadgeRequest, token: str = Depends(get_current_admin_token)):
+    try:
+        if user_manager.set_badge(username, data.badge):
+            return {
+                "success": True,
+                "message": f"Badge updated for {username}"
+            }
+        
+        return JSONResponse(
+            content={"error": "User not found"},
+            status_code=404
+        )
+    except ValueError as e:
+        return JSONResponse(
+            content={"error": str(e)},
+            status_code=400
+        )
+    except Exception as e:
+        return JSONResponse(
+            content={"error": str(e)},
+            status_code=500
+        )
+
+# ==================== 用户设置API ====================
+
+@app.get("/api/user/{username}/settings")
+async def get_user_settings(username: str):
+    """获取用户设置"""
+    print("\n" + "=" * 80)
+    print(f"📥 [API] 收到读取请求")
+    print(f"   URL: /api/user/{username}/settings")
+    print(f"   用户名: {username}")
+    print("=" * 80)
+    
+    try:
+        settings = user_manager.get_user_settings(username)
+        
+        print(f"📤 [API] 返回数据: {list(settings.keys())}")
+        print("=" * 80 + "\n")
+        
+        return {
+            "success": True,
+            "settings": settings
+        }
+    except Exception as e:
+        print(f"❌ [API] 异常: {e}")
+        import traceback
+        traceback.print_exc()
+        print("=" * 80 + "\n")
+        
+        return JSONResponse(
+            content={"success": False, "error": str(e)},
+            status_code=500
+        )
+
+# ==================== 用户数据同步接口（内部使用）====================
+class UserDataSync(BaseModel):
+    username: str
+    data: dict
+
+@app.post("/api/user/data/sync")
+async def sync_user_data(payload: UserDataSync):
+    """同步用户数据到 Redis（内部接口）"""
+    print(f"📡 [SYNC] 收到用户数据同步请求: {payload.username}")
+    print(f"   数据字段: {list(payload.data.keys())}")
+    
+    try:
+        success = user_manager.update_user_data(payload.username, payload.data)
+        
+        if success:
+            print(f"✅ [SYNC] 用户 {payload.username} 数据同步成功")
+            return {
+                "success": True,
+                "message": "数据已实时同步到Redis"
+            }
+        else:
+            print(f"❌ [SYNC] 用户 {payload.username} 不存在")
+            return JSONResponse(
+                content={"success": False, "error": "用户不存在"},
+                status_code=404
+            )
+    except Exception as e:
+        print(f"❌ [SYNC] 同步失败: {e}")
+        import traceback
+        traceback.print_exc()
+        return JSONResponse(
+            content={"success": False, "error": str(e)},
+            status_code=500
+        )
+
+# ==================== 用户行为跟踪接口 ====================
+class UserBehaviorLog(BaseModel):
+    username: str
+    action: str  # 'play', 'download', 'favorite', 'search', 'setting_change', etc.
+    data: dict   # 相关数据
+
+@app.post("/api/user/behavior/track")
+async def track_user_behavior(payload: UserBehaviorLog):
+    """实时跟踪用户行为并保存到Redis"""
+    print(f"📊 [BEHAVIOR] 跟踪用户行为: {payload.username} - {payload.action}")
+    
+    try:
+        # 获取当前用户数据
+        user_data = user_manager.get_user_data(payload.username)
+        if not user_data:
+            return JSONResponse(
+                content={"success": False, "error": "用户不存在"},
+                status_code=404
+            )
+        
+        # 根据行为类型更新相应数据
+        update_data = {}
+        
+        if payload.action == 'play':
+            # 更新播放历史
+            playback_history = user_data.get('playback_history', [])
+            playback_entry = {
+                'timestamp': datetime.now().isoformat(),
+                'channel_id': payload.data.get('channel_id'),
+                'channel_name': payload.data.get('channel_name'),
+                'duration': payload.data.get('duration', 0)
+            }
+            playback_history.insert(0, playback_entry)
+            # 保留最近100条记录
+            playback_history = playback_history[:100]
+            update_data['playback_history'] = playback_history
+            
+        elif payload.action == 'favorite':
+            # 更新收藏频道
+            favorite_channels = payload.data.get('favorite_channels', [])
+            update_data['favorite_channels'] = favorite_channels
+            
+        elif payload.action == 'setting_change':
+            # 更新设置
+            for key, value in payload.data.items():
+                if key in ['download_concurrency', 'batch_download_concurrency', 'fab_position']:
+                    update_data[key] = value
+                    
+        elif payload.action == 'reminder':
+            # 更新节目提醒
+            program_reminders = payload.data.get('program_reminders', [])
+            update_data['program_reminders'] = program_reminders
+        
+        # 实时保存到Redis
+        if update_data:
+            success = user_manager.update_user_data(payload.username, update_data)
+            if success:
+                print(f"✅ [BEHAVIOR] 用户 {payload.username} 行为数据已实时保存")
+                return {
+                    "success": True,
+                    "message": f"用户行为 '{payload.action}' 已实时保存到Redis"
+                }
+        
+        return JSONResponse(
+            content={"success": False, "error": "无效的行为数据"},
+            status_code=400
+        )
+        
+    except Exception as e:
+        print(f"❌ [BEHAVIOR] 行为跟踪失败: {e}")
+        import traceback
+        traceback.print_exc()
+        return JSONResponse(
+            content={"success": False, "error": str(e)},
+            status_code=500
+        )
+
+@app.get("/health")
+async def health_check():
+    stats = cache.get_stats()
+    is_valid, missing = Config.validate()
+
+    return {
+        "name": Config.APP_NAME,
+        "version": Config.APP_VERSION,
+        "description": Config.APP_DESCRIPTION,
+        "status": "running" if is_valid else "configuration_error",
+        "config_valid": is_valid,
+        "missing_config": missing if not is_valid else [],
+        "password_protected": len(user_manager.users) > 0,
+        "total_users": len(user_manager.users),
+        "cache": {
+            "storage_type": stats['storage_type'],
+            "cid": stats['cid'],
+            "auth": stats['auth'],
+            "channels": stats['channels'],
+            "streams": stats['streams'],
+            "epg": stats['epg'],
+            "epg_detail": stats.get('epg_detail')
+        },
+        "features": {
+            "streaming": True,
+            "download": True,
+            "live_recording": True,
+            "recording_mode": "Frontend Sequential Recording",
+            "user_management": True,
+            "admin_features": True,
+            "unified_login": True,
+            "cache_persistence": stats['storage_type'] in ['redis', 'disk'],
+            "user_settings_sync": True,
+            "auto_refresh": {
+                "cid": "1 day (auto refresh on expire)",
+                "auth": "3 hours (auto refresh on expire or 401/403)",
+                "storage": stats['storage_type'].upper()
+            }
+        }
+    }
+
+@app.get("/api/refresh")
+async def refresh_cache(type: str = "all"):
+    cache.clear_cache(type)
+    
+    if type in ['auth', 'all']:
+        try:
+            await get_auth(force=True)
+            message = f"{type.capitalize()} cache cleared and refreshed"
+        except Exception as e:
+            message = f"{type.capitalize()} cache cleared, but refresh failed: {str(e)}"
+    elif type == 'cid':
+        try:
+            from utils import get_cid
+            await get_cid(force=True)
+            message = "CID cache cleared and refreshed"
+        except Exception as e:
+            message = f"CID cache cleared, but refresh failed: {str(e)}"
+    else:
+        message = f"{type.capitalize()} cache cleared"
+    
+    return {
+        "success": True,
+        "message": message
+    }
+
+@app.get("/api/list")
+async def list_channels(request: Request):
+    try:
+        auth = await get_auth()
+        channels = await get_channels(auth)
+        
+        scheme = request.url.scheme
+        host = request.url.netloc
+        worker_base = f"{scheme}://{host}"
+        
+        rewritten_channels = [
+            {
+                **ch,
+                "playUrl": f"{worker_base}/api/live/{ch['no']}"
+            }
+            for ch in channels
+        ]
+        
+        return {
+            "success": True,
+            "count": len(rewritten_channels),
+            "channels": rewritten_channels,
+            "cached": cache.get_channels() is not None
+        }
+    
+    except Exception as e:
+        return JSONResponse(
+            content={"success": False, "error": str(e)},
+            status_code=500
+        )
+
+@app.get("/api/epg")
+async def get_epg(vid: str, date: str):
+    """获取单个频道某天的EPG，优先使用缓存"""
+    try:
+        if not vid or not date:
+            return JSONResponse(
+                content={"success": False, "error": "Missing vid or date"},
+                status_code=400
+            )
+        
+        auth = await get_auth()
+        
+        # 直接调用 fetch_epg，它会自动处理缓存
+        epg_data = await fetch_epg(vid, date, auth)
+        
+        return {
+            "success": True,
+            "vid": vid,
+            "date": date,
+            "count": len(epg_data),
+            "epg": epg_data,
+            "cached": cache.get_epg(vid, date) is not None
+        }
+    
+    except Exception as e:
+        return JSONResponse(
+            content={"success": False, "error": str(e)},
+            status_code=500
+        )
+
+
+@app.get("/api/epg/all")
+async def get_all_epg_data():
+    """获取所有EPG数据，优先使用缓存"""
+    try:
+        auth = await get_auth()
+        
+        # get_all_epg 会自动处理缓存
+        all_epg = await get_all_epg(auth, force=False)
+        
+        total_channels = len(all_epg)
+        total_programs = sum(len(programs) for programs in all_epg.values())
+        
+        return {
+            "success": True,
+            "total_channels": total_channels,
+            "total_programs": total_programs,
+            "data": all_epg,
+            "cached": cache.get_epg('_all_', 'full') is not None
+        }
+    
+    except Exception as e:
+        return JSONResponse(
+            content={"success": False, "error": str(e)},
+            status_code=500
+        )
+
+@app.get("/api/epg/search")
+async def search_epg(keyword: str, days: int = 30):
+    """搜索节目，快速返回结果，后台异步缓存"""
+    try:
+        if not keyword:
+            return JSONResponse(
+                content={"success": False, "error": "Missing keyword"},
+                status_code=400
+            )
+
+        auth = await get_auth()
+        channels_list = await get_channels(auth)
+        channel_map = {ch['id']: ch for ch in channels_list}
+
+        now = datetime.now()
+        date_list = []
+        for i in range(days + 1):
+            date_obj = now - timedelta(days=i)
+            date_str = get_jst_date(date_obj)
+            date_list.append(date_str)
+
+        results = []
+        keyword_lower = keyword.lower()
+        
+        cache_hits = 0
+        cache_misses = 0
+
+        # 检查是否有全量缓存
+        full_cache = cache.get_epg('_all_', 'full')
+        
+        if full_cache:
+            # 有全量缓存，直接搜索（最快）
+            for channel_id, programs in full_cache.items():
+                channel_info = channel_map.get(channel_id)
+                if not channel_info:
+                    continue
+                
+                for program in programs:
+                    program_time = program.get('time', 0)
+                    program_date = get_jst_date(datetime.fromtimestamp(program_time))
+                    
+                    if program_date not in date_list:
+                        continue
+                    
+                    title = program.get('title') or program.get('name') or ''
+                    if keyword_lower in title.lower():
+                        results.append({
+                            'channel_id': channel_id,
+                            'channel_name': channel_info['name'],
+                            'channel_no': channel_info['no'],
+                            'program': program,
+                            'date': program_date
+                        })
+                        cache_hits += 1
+        else:
+            # 没有全量缓存，使用智能搜索策略
+            # 策略：只获取和搜索数据，不等待全部缓存完成
+            
+            # 先从已有缓存中搜索
+            for channel_id, channel_info in channel_map.items():
+                for date_str in date_list:
+                    cached_epg = cache.get_epg(channel_id, date_str)
+                    
+                    if cached_epg is not None:
+                        # 从缓存中搜索
+                        cache_hits += 1
+                        for program in cached_epg:
+                            title = program.get('title') or program.get('name') or ''
+                            if keyword_lower in title.lower():
+                                results.append({
+                                    'channel_id': channel_id,
+                                    'channel_name': channel_info['name'],
+                                    'channel_no': channel_info['no'],
+                                    'program': program,
+                                    'date': date_str
+                                })
+                    else:
+                        cache_misses += 1
+            
+            # 如果没有足够的缓存，启动后台任务获取全量数据
+            if cache_hits == 0 or cache_misses > cache_hits:
+                # 后台异步获取全量EPG并缓存
+                asyncio.create_task(background_fetch_all_epg(auth))
+
+        # 排序结果
+        results.sort(key=lambda x: x['program']['time'], reverse=True)
+
+        return {
+            "success": True,
+            "keyword": keyword,
+            "days": days,
+            "total": len(results),
+            "results": results,
+            "cache_stats": {
+                "hits": cache_hits,
+                "misses": cache_misses,
+                "strategy": "full_cache" if full_cache else "partial_cache",
+                "hit_rate": f"{cache_hits * 100 // (cache_hits + cache_misses) if (cache_hits + cache_misses) > 0 else 0}%"
+            },
+            "message": "后台正在缓存数据，下次搜索会更快" if not full_cache and cache_misses > 0 else None
+        }
+
+    except Exception as e:
+        return JSONResponse(
+            content={"success": False, "error": str(e)},
+            status_code=500
+        )
+
+
+async def background_fetch_all_epg(auth: dict):
+    """后台异步任务：获取全量EPG数据"""
+    try:
+        # 调用 get_all_epg 来获取并缓存所有数据
+        await get_all_epg(auth, force=False)
+    except Exception as e:
+        # 静默失败，不影响用户体验
+        pass
+    
+@app.get("/api/live/{chid}")
+async def live_stream_info(chid: str, request: Request):
+    try:
+        auth = await get_auth()
+        channels = await get_channels(auth)
+        
+        channel = next((ch for ch in channels if str(ch['no']) == chid), None)
+        if not channel:
+            return JSONResponse(
+                content={
+                    "success": False,
+                    "error": f"Channel {chid} not found"
+                },
+                status_code=404
+            )
+        
+        scheme = request.url.scheme
+        host = request.url.netloc
+        worker_base = f"{scheme}://{host}"
+        
+        upstream_m3u8 = await get_live_m3u8_url(chid, auth)
+        
+        return {
+            "success": True,
+            "channel": {
+                "id": channel['id'],
+                "no": channel['no'],
+                "name": channel['name']
+            },
+            "stream": {
+                "m3u8": f"{worker_base}/stream/live/{chid}.m3u8",
+                "direct": upstream_m3u8
+            },
+            "info": {
+                "protocol": scheme,
+                "cached": cache.get_stream(f"live_{chid}") is not None
+            }
+        }
+    
+    except Exception as e:
+        return JSONResponse(
+            content={"success": False, "error": str(e)},
+            status_code=500
+        )
+
+@app.get("/stream/live/{chid}.m3u8")
+async def live_stream_m3u8(chid: str, request: Request):
+    return await proxy_live_stream_direct(chid, request)
+
+@app.get("/api/playback/{path:path}")
+async def playback_stream_info(path: str, request: Request):
+    try:
+        auth = await get_auth()
+        
+        scheme = request.url.scheme
+        host = request.url.netloc
+        worker_base = f"{scheme}://{host}"
+        
+        clean_path = path.strip('/')
+        if clean_path.startswith('/'):
+            clean_path = clean_path[1:]
+        
+        if not clean_path.startswith('query/'):
+            if '/' not in clean_path:
+                clean_path = f"query/{clean_path}"
+        
+        return {
+            "success": True,
+            "playback": {
+                "path": f"/{clean_path}",
+                "m3u8": f"{worker_base}/stream/playback/{clean_path}.m3u8",
+                "original_path": path
+            },
+            "info": {
+                "protocol": scheme,
+                "type": "playback"
+            }
+        }
+    
+    except Exception as e:
+        return JSONResponse(
+            content={"success": False, "error": str(e)},
+            status_code=500
+        )
+
+@app.get("/stream/playback/{path:path}.m3u8")
+async def playback_stream_m3u8(path: str, request: Request):
+    return await proxy_playback_stream(path, request)
+
+@app.get("/api/download/playback/")
+async def download_playback_by_path(
+    request: Request,
+    path: str,
+    channel: str
+):
+    try:
+        auth = await get_auth()
+        channels = await get_channels(auth)
+        target_channel = None
+        
+        for ch in channels:
+            if str(ch['no']) == str(channel):
+                target_channel = ch
+                break
+        
+        if not target_channel:
+            raise ValueError(f"频道 {channel} 不存在")
+        
+        clean_path = path.strip()
+        if clean_path.startswith('/'):
+            clean_path = clean_path[1:]
+        if clean_path.startswith('query/'):
+            clean_path = clean_path[6:]
+        
+        if clean_path.endswith('.m3u8'):
+            clean_path = clean_path[:-6]
+        
+        program_title = "Unknown"
+        program_time = None
+        found_date = None
+        
+        from datetime import timezone
+        JST = timezone(timedelta(hours=9))
+        now_jst = datetime.now(JST)
+        
+        for days_ago in range(0, 30):
+            check_date_jst = now_jst - timedelta(days=days_ago)
+            check_date = check_date_jst.strftime('%Y-%m-%d')
+            
+            try:
+                epg_list = await fetch_epg(target_channel['id'], check_date, auth)
+                
+                if not epg_list:
+                    continue
+                
+                for prog in epg_list:
+                    if prog.get('path'):
+                        prog_path = prog['path'].strip()
+                        if prog_path.startswith('/'):
+                            prog_path = prog_path[1:]
+                        if prog_path.startswith('query/'):
+                            prog_path = prog_path[6:]
+                        if prog_path.endswith('.m3u8'):
+                            prog_path = prog_path[:-6]
+                        
+                        if prog_path == clean_path:
+                            program_title = prog.get('title') or prog.get('name') or 'Unknown'
+                            program_time = datetime.fromtimestamp(prog['time'], tz=JST)
+                            found_date = check_date
+                            break
+                
+                if program_time:
+                    break
+                    
+            except Exception as e:
+                continue
+        
+        if not program_time:
+            program_time = now_jst
+            program_title = f"Playback_{target_channel['name']}"
+        
+        def clean_text(text):
+            import re
+            text = str(text).strip()
+            
+            forbidden_chars = r'[<>:"/\\|?*]'
+            cleaned = re.sub(forbidden_chars, '_', text)
+            
+            cleaned = re.sub(r'[\x00-\x1f\x7f-\x9f]', '', cleaned)
+            
+            cleaned = re.sub(r'_+', '_', cleaned)
+            
+            cleaned = cleaned.strip('_').strip()
+            
+            max_length = 150
+            if len(cleaned) > max_length:
+                if '】' in cleaned[:max_length]:
+                    pos = cleaned[:max_length].rfind('】')
+                    cleaned = cleaned[:pos+1]
+                elif '【' in cleaned[:max_length]:
+                    pos = cleaned[:max_length].rfind('【')
+                    cleaned = cleaned[:pos]
+                else:
+                    cleaned = cleaned[:max_length]
+            
+            return cleaned if cleaned else "unknown"
+        
+        time_str = program_time.strftime('%Y%m%d_%H%M')
+        channel_name = clean_text(target_channel['name'])
+        program_name = clean_text(program_title)
+        
+        filename = f"{time_str}_{channel_name}_{program_name}.ts"
+        
+        playback_path = path.strip()
+        if playback_path.startswith('/'):
+            playback_path = playback_path[1:]
+        if not playback_path.startswith('query/'):
+            playback_path = f"query/{playback_path}"
+        
+        vod_host = Config.UPSTREAM_HOSTS['vod']
+        from urllib.parse import quote
+        access_token = quote(auth['access_token'])
+        upstream_m3u8 = f"{vod_host}/{playback_path}.m3u8?type=vod&__cross_domain_user={access_token}"
+        
+        headers = {
+            'Referer': Config.REQUIRED_REFERER,
+            'User-Agent': 'Mozilla/5.0'
+        }
+        
+        async with httpx.AsyncClient(timeout=30.0) as client:
+            resp = await client.get(upstream_m3u8, headers=headers)
+            if resp.status_code != 200:
+                raise Exception(f"M3U8获取失败: HTTP {resp.status_code}")
+            m3u8_content = resp.text
+        
+        from utils import extract_playlist_url
+        playlist_url = extract_playlist_url(m3u8_content, upstream_m3u8)
+        
+        if not playlist_url or playlist_url == upstream_m3u8:
+            playlist_content = m3u8_content
+            playlist_url = upstream_m3u8
+        else:
+            async with httpx.AsyncClient(timeout=30.0) as client:
+                resp = await client.get(playlist_url, headers=headers)
+                if resp.status_code != 200:
+                    raise Exception(f"播放列表获取失败: HTTP {resp.status_code}")
+                playlist_content = resp.text
+        
+        base_url = playlist_url.rsplit('/', 1)[0]
+        ts_urls = []
+        for line in playlist_content.split('\n'):
+            line = line.strip()
+            if line and not line.startswith('#'):
+                ts_urls.append(line if line.startswith('http') else f"{base_url}/{line}")
+        
+        if len(ts_urls) == 0:
+            raise Exception("未找到TS分段")
+        
+        async def download_concurrent():
+            async def fetch_batch(client, batch, start_idx):
+                tasks = [client.get(url, headers=headers, timeout=60.0) for url in batch]
+                responses = await asyncio.gather(*tasks, return_exceptions=True)
+                
+                results = []
+                for i, resp in enumerate(responses):
+                    idx = start_idx + i
+                    if isinstance(resp, Exception):
+                        results.append((idx, None))
+                    elif resp.status_code == 200:
+                        results.append((idx, resp.content))
+                    else:
+                        results.append((idx, None))
+                
+                return results
+            
+            batch_size = 10
+            all_segments = {}
+            
+            async with httpx.AsyncClient(
+                timeout=60.0,
+                limits=httpx.Limits(max_keepalive_connections=20, max_connections=30)
+            ) as client:
+                for i in range(0, len(ts_urls), batch_size):
+                    batch = ts_urls[i:i+batch_size]
+                    batch_results = await fetch_batch(client, batch, i)
+                    
+                    for idx, content in batch_results:
+                        if content:
+                            all_segments[idx] = content
+                    
+                    progress = min(i + batch_size, len(ts_urls))
+                    percent = progress * 100 // len(ts_urls)
+            
+            for i in range(len(ts_urls)):
+                if i in all_segments:
+                    yield all_segments[i]
+            
+        from urllib.parse import quote
+        encoded_filename = quote(filename)
+        
+        return StreamingResponse(
+            download_concurrent(),
+            media_type="video/mp2t",
+            headers={
+                "Content-Disposition": f"attachment; filename*=UTF-8''{encoded_filename}",
+                "Cache-Control": "no-cache",
+            }
+        )
+        
+    except Exception as e:
+        return JSONResponse(
+            content={"success": False, "error": str(e)},
+            status_code=500
+        )
+        
+@app.options("/live/{path:path}")
+@app.options("/vod/{path:path}")
+@app.options("/query/{path:path}")
+@app.options("/stream/{path:path}")
+@app.options("/api/{path:path}")
+async def options_handler():
+    return Response(
+        status_code=200,
+        headers={
+            'Access-Control-Allow-Origin': '*',
+            'Access-Control-Allow-Methods': 'GET, POST, OPTIONS, DELETE',
+            'Access-Control-Allow-Headers': 'Authorization, Content-Type, Range',
+            'Access-Control-Max-Age': '3600'
+        }
+    )
+
+@app.get("/live/{path:path}")
+async def proxy_live_media(path: str, request: Request):
+    return await proxy_media(request, f"/live/{path}")
+
+@app.get("/vod/{path:path}")
+async def proxy_vod_media(path: str, request: Request):
+    return await proxy_media(request, f"/vod/{path}")
+
+@app.get("/query/{path:path}")
+async def proxy_query_media(path: str, request: Request):
+    return await proxy_media(request, f"/query/{path}")
+
+@app.exception_handler(404)
+async def not_found_handler(request: Request, exc):
+    return JSONResponse(
+        content={"error": "Not Found", "path": request.url.path},
+        status_code=404
+    )
+
+@app.exception_handler(500)
+async def server_error_handler(request: Request, exc):
+    return JSONResponse(
+        content={"error": "Internal Server Error", "detail": "An error occurred"},
+        status_code=500
+    )
+
+@app.on_event("startup")
+async def startup_event():
+    print("=" * 60)
+    print("🚀 Media Gateway 启动")
+    print("=" * 60)
+    
+    # 显示缓存状态
+    stats = cache.get_stats()
+    print(f"📦 存储类型: {stats['storage_type'].upper()}")
+    
+    if stats['storage_type'] == 'redis':
+        print("   ✅ Redis 持久化已启用")
+    elif stats['storage_type'] == 'disk':
+        print(f"   ✅ 磁盘缓存已启用: {cache.cache_dir}")
+        print(f"   📊 EPG 缓存: {stats.get('epg', 0)} 条")
+    else:
+        print("   ⚠️ 仅使用内存缓存（重启后丢失）")
+    
+    # 用户管理状态
+    if user_manager.redis:
+        print("👥 用户数据: Redis 持久化")
+    else:
+        print("👥 用户数据: 内存存储")
+    
+    # 配置验证
+    is_valid, missing = Config.validate()
+    if is_valid:
+        print("✅ 配置验证通过")
+    else:
+        print(f"⚠️ 缺少配置: {', '.join(missing)}")
+    
+    # 预加载缓存（可选）
+    try:
+        print("🔄 预加载数据...")
+        from utils import get_cid
+        cid = await get_cid()
+        
+        auth = await get_auth()
+        
+        channels = await get_channels(auth)
+        print(f"   ✅ 频道列表: {len(channels)} 个")
+    except Exception as e:
+        print(f"   ⚠️ 预加载失败: {e}")
+    
+    print("=" * 60)
+    print("✅ 启动完成！")
+    print("=" * 60)
+
+
+@app.on_event("shutdown")
+async def shutdown_event():
+    print("\n" + "=" * 60)
+    print("🛑 Media Gateway 关闭中...")
+    print("=" * 60)
+    
+    # 保存缓存
+    if cache.storage_type == 'disk':
+        cache._save_to_disk(force=True)
+        print(f"💾 磁盘缓存已保存 ({len(cache.epg)} 条 EPG)")
+    
+    # 保存用户数据
+    if not user_manager.redis and hasattr(user_manager, 'users'):
+        print(f"💾 用户数据已保存 ({len(user_manager.users)} 个用户)")
+    
+    print("✅ 关闭完成")
+    print("=" * 60)
+
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run(
+        app,
+        host="0.0.0.0",
+        port=7860,
+        log_level="error"
+    )

cache_manager.py

@@ -0,0 +1,503 @@
+import time
+import json
+import pickle
+import os
+from typing import Any, Optional, Dict
+from datetime import datetime, timedelta
+from pathlib import Path
+from config import Config
+
+try:
+    from upstash_redis import Redis
+except ImportError:
+    Redis = None
+
+class CacheManager:
+    def __init__(self):
+        self.storage_type = None
+        self.cache_dir = None
+        self.redis = None
+        
+        # 尝试初始化存储（优先级：Redis > Disk > Memory）
+        self._init_storage()
+        
+        # 初始化内存缓存
+        self.epg: Dict[str, Dict[str, Any]] = {}
+        self.cid: Optional[str] = None
+        self.cid_time: float = 0
+        self.auth: Optional[Dict[str, Any]] = None
+        self.auth_time: float = 0
+        self.channels: Optional[list] = None
+        self.channels_time: float = 0
+        self.stream_info: Dict[str, Dict[str, Any]] = {}
+        
+        # 加载已有缓存
+        self._load_cache()
+    
+    def _init_storage(self):
+        """初始化存储（Redis > Disk > Memory）"""
+        
+        # 1. 尝试 Redis
+        redis_url = os.getenv('REDIS_URL', '')
+        redis_token = os.getenv('REDIS_TOKEN', '')
+        
+        if Redis and redis_url and redis_token:
+            try:
+                self.redis = Redis(url=redis_url, token=redis_token)
+                self.redis.ping()
+                self.storage_type = 'redis'
+                print("✅ 使用 Redis 持久化存储")
+                return
+            except Exception as e:
+                print(f"⚠️ Redis 连接失败: {e}")
+                self.redis = None
+        
+        # 2. 尝试本地磁盘
+        cache_dir = Path(os.getenv('CACHE_DIR', '/tmp/cache'))
+        
+        try:
+            cache_dir.mkdir(parents=True, exist_ok=True)
+            (cache_dir / 'epg').mkdir(exist_ok=True)
+            
+            # 测试写入权限
+            test_file = cache_dir / '.test'
+            test_file.write_text('test')
+            test_file.unlink()
+            
+            self.cache_dir = cache_dir
+            self.storage_type = 'disk'
+            print(f"✅ 使用本地磁盘缓存: {cache_dir}")
+            print(f"   缓存将在容器运行期间保留")
+            return
+            
+        except Exception as e:
+            print(f"⚠️ 磁盘缓存不可用: {e}")
+        
+        # 3. 降级到内存
+        self.storage_type = 'memory'
+        print("⚠️ 使用内存缓存（容器重启后丢失）")
+    
+    def _load_cache(self):
+        """启动时加载缓存"""
+        if self.storage_type == 'redis':
+            self._load_from_redis()
+        elif self.storage_type == 'disk':
+            self._load_from_disk()
+    
+    def _load_from_redis(self):
+        """从 Redis 加载缓存"""
+        try:
+            # 加载 CID
+            cid_data = self.redis.get('cache:cid')
+            if cid_data:
+                data = json.loads(cid_data)
+                self.cid = data['value']
+                self.cid_time = data['time']
+            
+            # 加载 Auth
+            auth_data = self.redis.get('cache:auth')
+            if auth_data:
+                data = json.loads(auth_data)
+                self.auth = data['value']
+                self.auth_time = data['time']
+            
+            # 加载 Channels
+            channels_data = self.redis.get('cache:channels')
+            if channels_data:
+                data = json.loads(channels_data)
+                self.channels = data['value']
+                self.channels_time = data['time']
+            
+            print("✅ Redis 缓存加载完成")
+        except Exception as e:
+            print(f"⚠️ Redis 缓存加载失败: {e}")
+    
+    def _load_from_disk(self):
+        """从磁盘加载缓存"""
+        try:
+            # 加载 EPG 缓存
+            epg_file = self.cache_dir / 'epg_cache.pkl'
+            if epg_file.exists():
+                with open(epg_file, 'rb') as f:
+                    self.epg = pickle.load(f)
+                print(f"✅ 从磁盘加载 {len(self.epg)} 条 EPG 缓存")
+            
+            # 加载元数据缓存
+            meta_file = self.cache_dir / 'meta_cache.json'
+            if meta_file.exists():
+                with open(meta_file, 'r') as f:
+                    meta = json.load(f)
+                    if 'cid' in meta:
+                        self.cid = meta['cid'].get('value')
+                        self.cid_time = meta['cid'].get('time', 0)
+                    if 'auth' in meta:
+                        self.auth = meta['auth'].get('value')
+                        self.auth_time = meta['auth'].get('time', 0)
+                    if 'channels' in meta:
+                        self.channels = meta['channels'].get('value')
+                        self.channels_time = meta['channels'].get('time', 0)
+                print("✅ 从磁盘加载元数据缓存")
+                
+        except Exception as e:
+            print(f"⚠️ 磁盘缓存加载失败: {e}")
+    
+    def _save_to_disk(self, force=False):
+        """保存缓存到磁盘"""
+        if self.storage_type != 'disk' or not self.cache_dir:
+            return
+        
+        try:
+            # 保存 EPG（使用 pickle，快速）
+            epg_file = self.cache_dir / 'epg_cache.pkl'
+            with open(epg_file, 'wb') as f:
+                pickle.dump(self.epg, f, protocol=pickle.HIGHEST_PROTOCOL)
+            
+            # 保存元数据（使用 JSON，可读）
+            meta_file = self.cache_dir / 'meta_cache.json'
+            meta = {
+                'cid': {'value': self.cid, 'time': self.cid_time},
+                'auth': {'value': self.auth, 'time': self.auth_time},
+                'channels': {'value': self.channels, 'time': self.channels_time}
+            }
+            with open(meta_file, 'w') as f:
+                json.dump(meta, f)
+            
+            if force:
+                print(f"💾 磁盘缓存已保存 ({len(self.epg)} 条 EPG)")
+        except Exception as e:
+            print(f"⚠️ 磁盘缓存保存失败: {e}")
+    
+    # ==================== CID 缓存 ====================
+    
+    def get_cid(self) -> Optional[str]:
+        if self.cid and (time.time() - self.cid_time < Config.CACHE_TTL['CID']):
+            return self.cid
+        
+        if self.storage_type == 'redis':
+            try:
+                cid_data = self.redis.get('cache:cid')
+                if cid_data:
+                    data = json.loads(cid_data)
+                    if time.time() - data['time'] < Config.CACHE_TTL['CID']:
+                        self.cid = data['value']
+                        self.cid_time = data['time']
+                        return self.cid
+            except:
+                pass
+        
+        return None
+    
+    def set_cid(self, cid: str):
+        self.cid = cid
+        self.cid_time = time.time()
+        
+        if self.storage_type == 'redis':
+            try:
+                data = {'value': cid, 'time': self.cid_time}
+                self.redis.set('cache:cid', json.dumps(data), ex=Config.CACHE_TTL['CID'])
+            except:
+                pass
+        elif self.storage_type == 'disk':
+            self._save_to_disk()
+    
+    # ==================== Auth 缓存 ====================
+    
+    def get_auth(self) -> Optional[Dict[str, Any]]:
+        if self.auth and (time.time() - self.auth_time < Config.CACHE_TTL['AUTH']):
+            return self.auth
+        
+        if self.storage_type == 'redis':
+            try:
+                auth_data = self.redis.get('cache:auth')
+                if auth_data:
+                    data = json.loads(auth_data)
+                    if time.time() - data['time'] < Config.CACHE_TTL['AUTH']:
+                        self.auth = data['value']
+                        self.auth_time = data['time']
+                        return self.auth
+            except:
+                pass
+        
+        return None
+    
+    def set_auth(self, auth: Dict[str, Any]):
+        self.auth = auth
+        self.auth_time = time.time()
+        
+        if self.storage_type == 'redis':
+            try:
+                data = {'value': auth, 'time': self.auth_time}
+                self.redis.set('cache:auth', json.dumps(data), ex=Config.CACHE_TTL['AUTH'])
+            except:
+                pass
+        elif self.storage_type == 'disk':
+            self._save_to_disk()
+    
+    # ==================== Channels 缓存 ====================
+    
+    def get_channels(self) -> Optional[list]:
+        if self.channels and (time.time() - self.channels_time < Config.CACHE_TTL['CHANNELS']):
+            return self.channels
+        
+        if self.storage_type == 'redis':
+            try:
+                channels_data = self.redis.get('cache:channels')
+                if channels_data:
+                    data = json.loads(channels_data)
+                    if time.time() - data['time'] < Config.CACHE_TTL['CHANNELS']:
+                        self.channels = data['value']
+                        self.channels_time = data['time']
+                        return self.channels
+            except:
+                pass
+        
+        return None
+    
+    def set_channels(self, channels: list):
+        self.channels = channels
+        self.channels_time = time.time()
+        
+        if self.storage_type == 'redis':
+            try:
+                data = {'value': channels, 'time': self.channels_time}
+                self.redis.set('cache:channels', json.dumps(data), ex=Config.CACHE_TTL['CHANNELS'])
+            except:
+                pass
+        elif self.storage_type == 'disk':
+            self._save_to_disk()
+    
+    # ==================== Stream 缓存 ====================
+    
+    def get_stream(self, key: str) -> Optional[str]:
+        if key in self.stream_info:
+            cached = self.stream_info[key]
+            if time.time() - cached['time'] < Config.CACHE_TTL['STREAM']:
+                return cached['url']
+        return None
+    
+    def set_stream(self, key: str, url: str):
+        self.stream_info[key] = {'url': url, 'time': time.time()}
+        
+        if len(self.stream_info) > Config.MAX_STREAM_CACHE:
+            oldest_key = min(self.stream_info.keys(), 
+                           key=lambda k: self.stream_info[k]['time'])
+            del self.stream_info[oldest_key]
+    
+    # ==================== EPG 缓存 ====================
+    
+    def get_epg(self, vid: str, date: str) -> Optional[any]:
+        key = f"{vid}_{date}"
+        
+        # 检查内存缓存
+        if key in self.epg:
+            cached = self.epg[key]
+            
+            if vid == '_all_' and date == 'full':
+                if time.time() - cached['time'] < Config.CACHE_TTL['EPG_FULL']:
+                    return cached['data']
+            else:
+                today = self._get_jst_date()
+                ttl = Config.CACHE_TTL['EPG_TODAY'] if date == today else Config.CACHE_TTL['EPG_OTHER']
+                
+                if time.time() - cached['time'] < ttl:
+                    return cached['data']
+        
+        # 如果使用磁盘缓存，尝试从单独文件加载
+        if self.storage_type == 'disk' and vid != '_all_':
+            try:
+                epg_file = self.cache_dir / 'epg' / f"{key}.pkl"
+                if epg_file.exists():
+                    with open(epg_file, 'rb') as f:
+                        cached = pickle.load(f)
+                    
+                    today = self._get_jst_date()
+                    ttl = Config.CACHE_TTL['EPG_TODAY'] if date == today else Config.CACHE_TTL['EPG_OTHER']
+                    
+                    if time.time() - cached['time'] < ttl:
+                        # 加载到内存
+                        self.epg[key] = cached
+                        return cached['data']
+            except:
+                pass
+        
+        return None
+    
+    def set_epg(self, vid: str, date: str, data: any):
+        key = f"{vid}_{date}"
+        self.epg[key] = {
+            'data': data,
+            'time': time.time(),
+            'date': date,
+            'vid': vid
+        }
+        
+        # Redis 存储
+        if self.storage_type == 'redis':
+            # Redis 代码保持不变...
+            pass
+        
+        # 磁盘存储
+        elif self.storage_type == 'disk':
+            # 单独保存每个 EPG 文件（避免频繁写入大文件）
+            try:
+                epg_file = self.cache_dir / 'epg' / f"{key}.pkl"
+                with open(epg_file, 'wb') as f:
+                    pickle.dump(self.epg[key], f, protocol=pickle.HIGHEST_PROTOCOL)
+            except:
+                pass
+            
+            # 每 20 条更新一次主缓存文件
+            if len(self.epg) % 20 == 0:
+                self._save_to_disk()
+        
+        # 清理过期缓存
+        if len(self.epg) > Config.MAX_EPG_CACHE:
+            self._clean_old_epg()
+    
+    def _clean_old_epg(self):
+        """清理过期 EPG"""
+        cutoff_date = (datetime.now() - timedelta(days=Config.CACHE_TTL['EPG_MAX_DAYS'])).strftime('%Y-%m-%d')
+        to_delete = [k for k, v in self.epg.items() 
+                    if v.get('date', '') < cutoff_date and not k.startswith('_all_')]
+        
+        for k in to_delete:
+            del self.epg[k]
+            
+            # 删除磁盘文件
+            if self.storage_type == 'disk':
+                try:
+                    epg_file = self.cache_dir / 'epg' / f"{k}.pkl"
+                    if epg_file.exists():
+                        epg_file.unlink()
+                except:
+                    pass
+    
+    def _get_jst_date(self) -> str:
+        from datetime import timezone
+        jst = timezone(timedelta(hours=9))
+        now = datetime.now(jst)
+        return now.strftime('%Y-%m-%d')
+    
+    # ==================== 缓存管理 ====================
+    
+    def clear_cache(self, cache_type: str = 'all'):
+        if cache_type in ['cid', 'all']:
+            self.cid = None
+            self.cid_time = 0
+            if self.storage_type == 'redis':
+                try:
+                    self.redis.delete('cache:cid')
+                except:
+                    pass
+        
+        if cache_type in ['auth', 'all']:
+            self.auth = None
+            self.auth_time = 0
+            if self.storage_type == 'redis':
+                try:
+                    self.redis.delete('cache:auth')
+                except:
+                    pass
+        
+        if cache_type in ['channels', 'all']:
+            self.channels = None
+            self.channels_time = 0
+            if self.storage_type == 'redis':
+                try:
+                    self.redis.delete('cache:channels')
+                except:
+                    pass
+        
+        if cache_type in ['streams', 'all']:
+            self.stream_info.clear()
+        
+        if cache_type in ['epg', 'all']:
+            self.epg.clear()
+            
+            # 清理磁盘文件
+            if self.storage_type == 'disk' and self.cache_dir:
+                try:
+                    for epg_file in (self.cache_dir / 'epg').glob('*.pkl'):
+                        epg_file.unlink()
+                    (self.cache_dir / 'epg_cache.pkl').unlink(missing_ok=True)
+                except:
+                    pass
+        
+        # 保存更改
+        if self.storage_type == 'disk':
+            self._save_to_disk()
+    
+    def get_stats(self) -> dict:
+        return {
+            'storage_type': self.storage_type,
+            'cid': {
+                'cached': self.cid is not None,
+                'value': self.cid if self.cid else None,
+                'age': f"{int(time.time() - self.cid_time)}s" if self.cid else None,
+                'ttl': f"{Config.CACHE_TTL['CID'] - int(time.time() - self.cid_time)}s" if self.cid else None,
+                'storage': self.storage_type
+            },
+            'auth': {
+                'cached': self.auth is not None,
+                'token': self.auth['access_token'] if self.auth and 'access_token' in self.auth else None,
+                'age': f"{int(time.time() - self.auth_time)}s" if self.auth else None,
+                'ttl': f"{Config.CACHE_TTL['AUTH'] - int(time.time() - self.auth_time)}s" if self.auth else None,
+                'storage': self.storage_type
+            },
+            'channels': self.channels is not None,
+            'streams': len(self.stream_info),
+            'epg': len(self.epg),
+            'epg_detail': self.get_epg_cache_info() if self.epg else None
+        }
+    
+    def get_epg_cache_info(self) -> dict:
+        """获取 EPG 缓存详细信息"""
+        info = {
+            'total_entries': len(self.epg),
+            'by_channel': {},
+            'by_date': {},
+            'full_cache_available': False
+        }
+        
+        # 检查全量缓存
+        if '_all__full' in self.epg:
+            info['full_cache_available'] = True
+            full_cache = self.epg['_all__full']
+            info['full_cache_time'] = datetime.fromtimestamp(full_cache['time']).strftime('%Y-%m-%d %H:%M:%S')
+            info['full_cache_age'] = f"{int(time.time() - full_cache['time'])}s"
+        
+        # 统计各频道和日期
+        for key, value in self.epg.items():
+            if key == '_all__full':
+                continue
+            
+            vid = value.get('vid', 'unknown')
+            date = value.get('date', 'unknown')
+            
+            if vid not in info['by_channel']:
+                info['by_channel'][vid] = {'dates': [], 'program_count': 0}
+            info['by_channel'][vid]['dates'].append(date)
+            info['by_channel'][vid]['program_count'] += len(value.get('data', []))
+            
+            if date not in info['by_date']:
+                info['by_date'][date] = {'channels': [], 'program_count': 0}
+            info['by_date'][date]['channels'].append(vid)
+            info['by_date'][date]['program_count'] += len(value.get('data', []))
+        
+        info['summary'] = {
+            'total_channels': len(info['by_channel']),
+            'total_dates': len(info['by_date']),
+            'total_programs': sum(ch['program_count'] for ch in info['by_channel'].values())
+        }
+        
+        return info
+    
+    def __del__(self):
+        """程序退出时保存缓存"""
+        if self.storage_type == 'disk':
+            self._save_to_disk(force=True)
+            print("💾 缓存已保存到磁盘")
+
+
+# 全局单例
+cache = CacheManager()

config.py

@@ -0,0 +1,153 @@
+import os
+from pathlib import Path
+from typing import Dict
+from dotenv import load_dotenv
+
+env_path = Path(__file__).parent / '.env'
+if env_path.exists():
+    load_dotenv(dotenv_path=env_path)
+
+class Config:
+    APP_NAME = os.getenv('APP_NAME', 'Media Gateway')
+    APP_DESCRIPTION = os.getenv('APP_DESCRIPTION', 'Streaming Media Service')
+    APP_VERSION = os.getenv('APP_VERSION', '1.0.0')
+    
+    API_KEY = os.getenv('API_KEY', '')
+    REQUIRED_REFERER = os.getenv('REQUIRED_REFERER', '')
+    LIST_LIVES_CID = os.getenv('LIST_LIVES_CID', '')
+    
+    UPSTREAM_HOSTS = {
+        'live': os.getenv('UPSTREAM_HOST_LIVE', ''),
+        'vod': os.getenv('UPSTREAM_HOST_VOD', '')
+    }
+    CID_API_URL = os.getenv('CID_API_URL', '')
+    LOGIN_API_URL = os.getenv('LOGIN_API_URL', '')
+    LIST_API_URL = os.getenv('LIST_API_URL', '')
+    EPG_API_URL = os.getenv('EPG_API_URL', '')
+    
+    @classmethod
+    @property
+    def LIST_API_URL_WITH_EPG(cls):
+        if cls.LIST_API_URL:
+            return cls.LIST_API_URL.replace('no_epg=1', 'no_epg=0')
+        return ''
+    
+    LOGIN_PASSWORD = os.getenv('LOGIN_PASSWORD', '')
+    LOGIN_APP_ID = os.getenv('LOGIN_APP_ID', '')
+    LOGIN_DEVICE_ID = os.getenv('LOGIN_DEVICE_ID', '')
+    
+    ADMIN_USERNAME = os.getenv('ADMIN_USERNAME', '')
+    ADMIN_PASSWORD_HASH = os.getenv('ADMIN_PASSWORD_HASH', '')  
+    
+    USER_PASSWORD_EXPIRY_DAYS = int(os.getenv('USER_PASSWORD_EXPIRY_DAYS', '30'))  
+    MAX_USERS = int(os.getenv('MAX_USERS', '50')) 
+    REDIS_URL = os.getenv('REDIS_URL', '')
+    REDIS_TOKEN = os.getenv('REDIS_TOKEN', '')
+    
+    CACHE_TTL: Dict[str, int] = {
+        'CID': int(os.getenv('CACHE_TTL_CID', '86400')),
+        'AUTH': int(os.getenv('CACHE_TTL_AUTH', '10800')),
+        'CHANNELS': int(os.getenv('CACHE_TTL_CHANNELS', '86400')),
+        'STREAM': int(os.getenv('CACHE_TTL_STREAM', '21600')),
+        'EPG_TODAY': int(os.getenv('CACHE_TTL_EPG_TODAY', '300')),
+        'EPG_OTHER': int(os.getenv('CACHE_TTL_EPG_OTHER', '86400')),
+        'EPG_MAX_DAYS': int(os.getenv('CACHE_TTL_EPG_MAX_DAYS', '30')),
+        'EPG_FULL': int(os.getenv('CACHE_TTL_EPG_FULL', '3600')),
+    }
+    
+    TIMEOUT = int(os.getenv('HTTP_TIMEOUT', '60'))  
+    CONNECT_TIMEOUT = int(os.getenv('HTTP_CONNECT_TIMEOUT', '10'))  
+    MAX_STREAM_CACHE = int(os.getenv('MAX_STREAM_CACHE', '200'))  
+    MAX_EPG_CACHE = int(os.getenv('MAX_EPG_CACHE', '1000'))  
+    DEBUG = os.getenv('DEBUG', 'false').lower() == 'true'
+    
+    ENABLE_GZIP = os.getenv('ENABLE_GZIP', 'true').lower() == 'true'
+    MAX_CONCURRENT_REQUESTS = int(os.getenv('MAX_CONCURRENT_REQUESTS', '100'))
+    
+    @classmethod
+    def get_cid_url(cls) -> str:
+        return cls.CID_API_URL.replace('{API_KEY}', cls.API_KEY)
+    
+    @classmethod
+    def get_login_url(cls, cid: str) -> str:
+        return (cls.LOGIN_API_URL
+                .replace('{CID}', cid)
+                .replace('{PASSWORD}', cls.LOGIN_PASSWORD)
+                .replace('{APP_ID}', cls.LOGIN_APP_ID)
+                .replace('{DEVICE_ID}', cls.LOGIN_DEVICE_ID))
+    
+    @classmethod
+    def get_list_url(cls, uid: str, with_epg: bool = False) -> str:
+        if with_epg:
+            url = cls.LIST_API_URL.replace('no_epg=1', 'no_epg=0')
+        else:
+            url = cls.LIST_API_URL
+        
+        url = url.replace('{UPSTREAM_HOST}', cls.UPSTREAM_HOSTS['live'])
+        url = url.replace('{CID}', cls.LIST_LIVES_CID)
+        url = url.replace('{UID}', uid)
+        url = url.replace('{REFERER}', cls.REQUIRED_REFERER)
+        return url
+    
+    @classmethod
+    def get_epg_url(cls, uid: str, vid: str) -> str:
+        url = cls.EPG_API_URL
+        url = url.replace('{UPSTREAM_HOST}', cls.UPSTREAM_HOSTS['live'])
+        url = url.replace('{CID}', cls.LIST_LIVES_CID)
+        url = url.replace('{UID}', uid)
+        url = url.replace('{VID}', vid)
+        url = url.replace('{REFERER}', cls.REQUIRED_REFERER)
+        return url
+    
+    @classmethod
+    def validate(cls) -> tuple[bool, list[str]]:
+        missing = []
+        
+        required_vars = {
+            'API_KEY': cls.API_KEY,
+            'REQUIRED_REFERER': cls.REQUIRED_REFERER,
+            'LIST_LIVES_CID': cls.LIST_LIVES_CID,
+            'UPSTREAM_HOST_LIVE': cls.UPSTREAM_HOSTS['live'],
+            'UPSTREAM_HOST_VOD': cls.UPSTREAM_HOSTS['vod'],
+            'CID_API_URL': cls.CID_API_URL,
+            'LOGIN_API_URL': cls.LOGIN_API_URL,
+            'LIST_API_URL': cls.LIST_API_URL,
+            'EPG_API_URL': cls.EPG_API_URL,
+            'LOGIN_PASSWORD': cls.LOGIN_PASSWORD,
+            'LOGIN_APP_ID': cls.LOGIN_APP_ID,
+            'LOGIN_DEVICE_ID': cls.LOGIN_DEVICE_ID
+        }
+        
+        for var_name, var_value in required_vars.items():
+            if not var_value:
+                missing.append(var_name)
+        
+        return (len(missing) == 0, missing)
+    
+    @classmethod
+    def get_masked_config(cls) -> dict:
+        def mask(value: str, show_chars: int = 4) -> str:
+            if not value or len(value) <= show_chars:
+                return '***'
+            return value[:show_chars] + '***'
+        
+        return {
+            'APP_NAME': cls.APP_NAME,
+            'APP_VERSION': cls.APP_VERSION,
+            'API_KEY': mask(cls.API_KEY),
+            'REQUIRED_REFERER': mask(cls.REQUIRED_REFERER, 10),
+            'LIST_LIVES_CID': mask(cls.LIST_LIVES_CID, 8),
+            'UPSTREAM_HOST_LIVE': cls.UPSTREAM_HOSTS['live'],
+            'UPSTREAM_HOST_VOD': cls.UPSTREAM_HOSTS['vod'],
+            'CID_API_URL': mask(cls.CID_API_URL, 15),
+            'LOGIN_API_URL': mask(cls.LOGIN_API_URL, 15),
+            'LOGIN_PASSWORD': '***',
+            'LOGIN_APP_ID': mask(cls.LOGIN_APP_ID, 8),
+            'LOGIN_DEVICE_ID': mask(cls.LOGIN_DEVICE_ID, 8),
+            'CACHE_TTL': cls.CACHE_TTL,
+            'TIMEOUT': cls.TIMEOUT,
+            'CONNECT_TIMEOUT': cls.CONNECT_TIMEOUT,
+            'MAX_STREAM_CACHE': cls.MAX_STREAM_CACHE,
+            'MAX_EPG_CACHE': cls.MAX_EPG_CACHE,
+            'DEBUG': cls.DEBUG
+        }

proxy_handler.py

@@ -0,0 +1,308 @@
+import httpx
+from urllib.parse import quote, urlparse
+from fastapi import Request
+from fastapi.responses import Response
+from config import Config
+from cache_manager import cache
+from utils import get_auth, get_channels, rewrite_m3u8, extract_playlist_url
+
+def get_client_base_url(request: Request) -> str:
+    scheme = request.url.scheme
+    netloc = request.url.netloc
+    return f"{scheme}://{netloc}"
+
+async def get_live_m3u8_url(chid: str, auth: dict, retry_count: int = 0) -> str:
+    try:
+        channels = await get_channels(auth)
+        channel = next((ch for ch in channels if str(ch['no']) == chid), None)
+        
+        if not channel:
+            raise ValueError(f"Channel {chid} not found")
+        
+        cache_key = f"live_{chid}"
+        playlist_url = cache.get_stream(cache_key)
+        
+        if not playlist_url:
+            source_url = (
+                f"{auth['vms_host']}{channel['playpath']}.M3U8"
+                f"?type=live&__cross_domain_user={quote(auth['access_token'])}"
+            )
+            source_url = source_url.replace(auth['vms_host'], Config.UPSTREAM_HOSTS['live'])
+            
+            headers = {
+                'Referer': Config.REQUIRED_REFERER,
+                'User-Agent': 'Mozilla/5.0'
+            }
+            
+            async with httpx.AsyncClient(
+                timeout=httpx.Timeout(30.0, connect=5.0),
+                follow_redirects=True,
+                limits=httpx.Limits(max_keepalive_connections=50, max_connections=200)
+            ) as client:
+                main_response = await client.get(source_url, headers=headers)
+                
+                if main_response.status_code in [401, 403] and retry_count < 2:
+                    new_auth = await get_auth(force=True)
+                    return await get_live_m3u8_url(chid, new_auth, retry_count + 1)
+                
+                main_response.raise_for_status()
+                main_content = main_response.text
+                
+                playlist_url = extract_playlist_url(main_content, source_url)
+                if not playlist_url:
+                    playlist_url = source_url
+                
+                cache.set_stream(cache_key, playlist_url)
+        
+        return playlist_url
+    
+    except httpx.HTTPStatusError as e:
+        if e.response.status_code in [401, 403] and retry_count < 2:
+            new_auth = await get_auth(force=True)
+            return await get_live_m3u8_url(chid, new_auth, retry_count + 1)
+        raise e
+
+async def proxy_live_stream_direct(chid: str, request: Request) -> Response:
+    try:
+        auth = await get_auth()
+        playlist_url = await get_live_m3u8_url(chid, auth)
+        
+        headers = {
+            'Referer': Config.REQUIRED_REFERER,
+            'User-Agent': 'Mozilla/5.0'
+        }
+        
+        async with httpx.AsyncClient(
+            timeout=httpx.Timeout(30.0, connect=5.0),
+            follow_redirects=True,
+            limits=httpx.Limits(max_keepalive_connections=50, max_connections=200)
+        ) as client:
+            playlist_response = await client.get(playlist_url, headers=headers)
+            playlist_response.raise_for_status()
+            playlist_content = playlist_response.text
+            
+            parsed = urlparse(playlist_url)
+            playlist_path = parsed.path + ('?' + parsed.query if parsed.query else '')
+            
+            worker_base = get_client_base_url(request)
+            rewritten = rewrite_m3u8(playlist_content, playlist_path, worker_base)
+            
+            return Response(
+                content=rewritten,
+                media_type='application/vnd.apple.mpegurl',
+                headers={
+                    'Cache-Control': 'public, max-age=10',
+                    'Access-Control-Allow-Origin': '*',
+                    'Access-Control-Allow-Headers': 'Range',
+                    'Access-Control-Expose-Headers': 'Content-Length, Content-Range'
+                }
+            )
+    
+    except httpx.HTTPError as e:
+        return Response(
+            content=f'{{"error": "Upstream error: {str(e)}"}}',
+            status_code=502,
+            media_type='application/json'
+        )
+    except Exception as e:
+        return Response(
+            content=f'{{"error": "{str(e)}"}}',
+            status_code=500,
+            media_type='application/json'
+        )
+
+async def proxy_playback_stream(path: str, request: Request, retry_count: int = 0) -> Response:
+    try:
+        auth = await get_auth()
+        
+        if not path.startswith('query/'):
+            path = f"query/{path}"
+        
+        vod_path = path.replace('.m3u8', '')
+        cache_key = f"vod_{vod_path.replace('/', '_').replace('=', '')}"
+        playlist_url = cache.get_stream(cache_key)
+        
+        if not playlist_url:
+            source_url = (
+                f"{Config.UPSTREAM_HOSTS['vod']}/{vod_path}.m3u8"
+                f"?type=vod&__cross_domain_user={quote(auth['access_token'])}"
+            )
+            
+            headers = {
+                'Referer': Config.REQUIRED_REFERER,
+                'User-Agent': 'Mozilla/5.0'
+            }
+            
+            async with httpx.AsyncClient(
+                timeout=httpx.Timeout(30.0, connect=5.0),
+                follow_redirects=True,
+                limits=httpx.Limits(max_keepalive_connections=50, max_connections=200)
+            ) as client:
+                main_response = await client.get(source_url, headers=headers)
+                
+                if main_response.status_code in [401, 403] and retry_count < 2:
+                    new_auth = await get_auth(force=True)
+                    return await proxy_playback_stream(path, request, retry_count + 1)
+                
+                if not main_response.is_success:
+                    raise Exception(f"VOD source failed: HTTP {main_response.status_code}")
+                
+                main_content = main_response.text
+                playlist_url = extract_playlist_url(main_content, source_url)
+                
+                if not playlist_url:
+                    playlist_url = source_url
+                
+                cache.set_stream(cache_key, playlist_url)
+        
+        headers = {
+            'Referer': Config.REQUIRED_REFERER,
+            'User-Agent': 'Mozilla/5.0'
+        }
+        
+        async with httpx.AsyncClient(
+            timeout=httpx.Timeout(30.0, connect=5.0),
+            follow_redirects=True,
+            limits=httpx.Limits(max_keepalive_connections=50, max_connections=200)
+        ) as client:
+            playlist_response = await client.get(playlist_url, headers=headers)
+            
+            if not playlist_response.is_success:
+                raise Exception(f"VOD playlist failed: HTTP {playlist_response.status_code}")
+            
+            playlist_content = playlist_response.text
+            
+            parsed = urlparse(playlist_url)
+            playlist_path = parsed.path + ('?' + parsed.query if parsed.query else '')
+            
+            worker_base = get_client_base_url(request)
+            rewritten = rewrite_m3u8(playlist_content, playlist_path, worker_base)
+            
+            return Response(
+                content=rewritten,
+                media_type='application/vnd.apple.mpegurl',
+                headers={
+                    'Cache-Control': 'public, max-age=60',
+                    'Access-Control-Allow-Origin': '*',
+                    'Access-Control-Allow-Headers': 'Range',
+                    'Access-Control-Expose-Headers': 'Content-Length, Content-Range'
+                }
+            )
+    
+    except httpx.HTTPStatusError as e:
+        if e.response.status_code in [401, 403] and retry_count < 2:
+            new_auth = await get_auth(force=True)
+            return await proxy_playback_stream(path, request, retry_count + 1)
+        
+        return Response(
+            content=f'{{"error": "Upstream error: {str(e)}"}}',
+            status_code=502,
+            media_type='application/json'
+        )
+    except Exception as e:
+        return Response(
+            content=f'{{"error": "{str(e)}"}}',
+            status_code=500,
+            media_type='application/json'
+        )
+
+async def proxy_media(request: Request, path: str, retry_count: int = 0) -> Response:
+    try:
+        auth = await get_auth()
+        
+        if path.startswith('/live/'):
+            upstream_host = Config.UPSTREAM_HOSTS['live']
+        elif path.startswith('/vod/') or path.startswith('/query/'):
+            upstream_host = Config.UPSTREAM_HOSTS['vod']
+        else:
+            upstream_host = Config.UPSTREAM_HOSTS['live']
+        
+        query = str(request.url.query)
+        upstream_url = f"{upstream_host}{path}"
+        if query:
+            upstream_url += f"?{query}"
+        
+        headers = {
+            'Referer': Config.REQUIRED_REFERER,
+            'User-Agent': 'Mozilla/5.0'
+        }
+        
+        range_header = request.headers.get('Range')
+        if range_header:
+            headers['Range'] = range_header
+        
+        async with httpx.AsyncClient(
+            timeout=httpx.Timeout(30.0, connect=5.0),
+            follow_redirects=True,
+            limits=httpx.Limits(
+                max_keepalive_connections=50,
+                max_connections=200,
+                keepalive_expiry=30.0
+            )
+        ) as client:
+            response = await client.get(upstream_url, headers=headers)
+            
+            if response.status_code in [401, 403] and retry_count < 2:
+                new_auth = await get_auth(force=True)
+                return await proxy_media(request, path, retry_count + 1)
+            
+            response.raise_for_status()
+            
+            content_type = response.headers.get('Content-Type', '')
+            
+            if 'mpegurl' in content_type or path.endswith(('.m3u8', '.M3U8')):
+                content = response.text
+                worker_base = get_client_base_url(request)
+                
+                full_path = path
+                if query:
+                    full_path += f"?{query}"
+                
+                rewritten = rewrite_m3u8(content, full_path, worker_base)
+                
+                return Response(
+                    content=rewritten,
+                    media_type='application/vnd.apple.mpegurl',
+                    headers={
+                        'Cache-Control': 'public, max-age=10',
+                        'Access-Control-Allow-Origin': '*'
+                    }
+                )
+            
+            response_headers = {
+                'Content-Type': content_type or 'video/MP2T',
+                'Cache-Control': 'public, max-age=86400',
+                'Access-Control-Allow-Origin': '*',
+                'Access-Control-Allow-Headers': 'Range',
+                'Access-Control-Expose-Headers': 'Content-Length, Content-Range'
+            }
+            
+            if 'Content-Length' in response.headers:
+                response_headers['Content-Length'] = response.headers['Content-Length']
+            if 'Content-Range' in response.headers:
+                response_headers['Content-Range'] = response.headers['Content-Range']
+            if 'Accept-Ranges' in response.headers:
+                response_headers['Accept-Ranges'] = response.headers['Accept-Ranges']
+            
+            return Response(
+                content=response.content,
+                status_code=response.status_code,
+                headers=response_headers
+            )
+    
+    except httpx.HTTPStatusError as e:
+        if e.response.status_code in [401, 403] and retry_count < 2:
+            new_auth = await get_auth(force=True)
+            return await proxy_media(request, path, retry_count + 1)
+        
+        return Response(
+            content=f'{{"error": "Upstream error: {str(e)}"}}',
+            status_code=502,
+            media_type='application/json'
+        )
+    except Exception as e:
+        return Response(
+            content=f'{{"error": "{str(e)}"}}',
+            status_code=500,
+            media_type='application/json'
+        )

requirements.txt

@@ -0,0 +1,10 @@
+fastapi==0.109.0
+uvicorn[standard]==0.27.0
+httpx==0.26.0
+aiohttp==3.9.1
+python-dateutil==2.8.2
+python-dotenv==1.0.0
+pydantic==2.5.0
+upstash-redis==0.15.0
+beautifulsoup4==4.12.3
+lxml==5.1.0

static/admin-login.html

@@ -0,0 +1,519 @@
+<!DOCTYPE html>
+<html lang="zh-CN">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>管理员登录 - Media Gateway</title>
+    <link rel="preconnect" href="https://fonts.googleapis.com">
+    <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>
+    <style>
+        @import url('https://fonts.googleapis.com/css2?family=Inter:wght@300;400;500;600;700;800&display=swap');
+
+        * {
+            margin: 0;
+            padding: 0;
+            box-sizing: border-box;
+        }
+
+        body {
+            font-family: 'Inter', -apple-system, BlinkMacSystemFont, 'Segoe UI', sans-serif;
+            background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+            background-size: 200% 200%;
+            animation: gradientShift 15s ease infinite;
+            min-height: 100vh;
+            display: flex;
+            align-items: center;
+            justify-content: center;
+            padding: 20px;
+        }
+
+        @keyframes gradientShift {
+            0% { background-position: 0% 50%; }
+            50% { background-position: 100% 50%; }
+            100% { background-position: 0% 50%; }
+        }
+
+        @keyframes slideIn {
+            from {
+                opacity: 0;
+                transform: translateY(-30px);
+            }
+            to {
+                opacity: 1;
+                transform: translateY(0);
+            }
+        }
+
+        @keyframes shake {
+            0%, 100% { transform: translateX(0); }
+            25% { transform: translateX(-10px); }
+            75% { transform: translateX(10px); }
+        }
+
+        .login-container {
+            background: rgba(255, 255, 255, 0.95);
+            backdrop-filter: blur(20px);
+            border-radius: 30px;
+            box-shadow: 0 30px 80px rgba(0, 0, 0, 0.3);
+            overflow: hidden;
+            max-width: 480px;
+            width: 100%;
+            animation: slideIn 0.6s ease;
+        }
+
+        .login-header {
+            background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+            color: white;
+            padding: 50px 40px;
+            text-align: center;
+        }
+
+        .login-header h1 {
+            font-size: 2.5em;
+            margin-bottom: 12px;
+            font-weight: 800;
+        }
+
+        .login-header p {
+            font-size: 1.1em;
+            opacity: 0.95;
+        }
+
+        .login-body {
+            padding: 40px;
+        }
+
+        .form-group {
+            margin-bottom: 25px;
+        }
+
+        .form-group label {
+            display: block;
+            margin-bottom: 10px;
+            font-weight: 600;
+            color: #1e293b;
+            font-size: 0.95em;
+        }
+
+        .input-wrapper {
+            position: relative;
+        }
+
+        .form-group input {
+            width: 100%;
+            padding: 16px 20px;
+            border: 2px solid #e2e8f0;
+            border-radius: 12px;
+            font-size: 1em;
+            transition: all 0.3s ease;
+            background: white;
+            font-family: inherit;
+        }
+
+        .form-group input:focus {
+            outline: none;
+            border-color: #6366f1;
+            box-shadow: 0 0 0 4px rgba(99, 102, 241, 0.1);
+        }
+
+        .password-toggle {
+            position: absolute;
+            right: 16px;
+            top: 50%;
+            transform: translateY(-50%);
+            background: none;
+            border: none;
+            cursor: pointer;
+            color: #64748b;
+            font-size: 1.3em;
+            padding: 6px;
+        }
+
+        .password-toggle:hover {
+            color: #6366f1;
+        }
+
+        .btn-login {
+            width: 100%;
+            padding: 18px;
+            background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+            color: white;
+            border: none;
+            border-radius: 12px;
+            font-size: 1.1em;
+            font-weight: 700;
+            cursor: pointer;
+            transition: all 0.3s ease;
+        }
+
+        .btn-login:hover:not(:disabled) {
+            transform: translateY(-3px);
+            box-shadow: 0 12px 35px rgba(99, 102, 241, 0.4);
+        }
+
+        .btn-login:disabled {
+            opacity: 0.7;
+            cursor: not-allowed;
+        }
+
+        .error-message {
+            background: linear-gradient(135deg, #fee2e2 0%, #fecaca 100%);
+            color: #991b1b;
+            padding: 16px;
+            border-radius: 12px;
+            margin-bottom: 20px;
+            display: none;
+            animation: shake 0.5s;
+            border: 2px solid #fca5a5;
+        }
+
+        .error-message.show {
+            display: block;
+        }
+
+        .success-message {
+            background: linear-gradient(135deg, #d1fae5 0%, #a7f3d0 100%);
+            color: #065f46;
+            padding: 16px;
+            border-radius: 12px;
+            margin-bottom: 20px;
+            display: none;
+            border: 2px solid #6ee7b7;
+        }
+
+        .success-message.show {
+            display: block;
+        }
+
+        .info-box {
+            background: linear-gradient(135deg, #dbeafe 0%, #bfdbfe 100%);
+            color: #1e40af;
+            padding: 16px;
+            border-radius: 12px;
+            margin-bottom: 25px;
+            font-size: 0.9em;
+            line-height: 1.6;
+            border: 1px solid #93c5fd;
+        }
+
+        .info-box strong {
+            display: block;
+            margin-bottom: 8px;
+            font-size: 1.05em;
+        }
+
+        .login-footer {
+            padding: 25px 40px;
+            background: rgba(248, 250, 252, 0.8);
+            text-align: center;
+            color: #64748b;
+            font-size: 0.9em;
+            border-top: 1px solid #e2e8f0;
+        }
+
+        .login-footer a {
+            color: #6366f1;
+            text-decoration: none;
+            font-weight: 600;
+        }
+
+        .login-footer a:hover {
+            text-decoration: underline;
+        }
+
+        @media (max-width: 480px) {
+            .login-container {
+                margin: 10px;
+            }
+
+            .login-header {
+                padding: 40px 30px;
+            }
+
+            .login-header h1 {
+                font-size: 2em;
+            }
+
+            .login-body {
+                padding: 30px 25px;
+            }
+        }
+    </style>
+</head>
+<body>
+    <div class="login-container">
+        <div class="login-header">
+            <h1>🔐 管理员登录</h1>
+            <p>Media Gateway Admin Panel</p>
+        </div>
+
+        <div class="login-body">
+            <div id="errorMessage" class="error-message"></div>
+            <div id="successMessage" class="success-message"></div>
+
+            <div class="info-box">
+                <strong>💡 管理员功能</strong>
+                登录后可创建和管理用户账号，配置系统设置
+            </div>
+
+            <form id="loginForm">
+                <div class="form-group">
+                    <label for="username">👤 管理员账号</label>
+                    <input 
+                        type="text" 
+                        id="username" 
+                        placeholder="请输入管理员账号"
+                        required 
+                        autocomplete="username"
+                    >
+                </div>
+
+                <div class="form-group">
+                    <label for="password">🔒 管理员密码</label>
+                    <div class="input-wrapper">
+                        <input 
+                            type="password" 
+                            id="password"
+                            placeholder="请输入管理员密码"
+                            required 
+                            autocomplete="current-password"
+                        >
+                        <button type="button" class="password-toggle" id="togglePassword">
+                            👁️
+                        </button>
+                    </div>
+                </div>
+
+                <button type="submit" class="btn-login" id="loginBtn">
+                    🚀 登录管理后台
+                </button>
+            </form>
+        </div>
+
+        <div class="login-footer">
+            <a href="/">← 返回首页</a>
+        </div>
+    </div>
+
+    <script>
+        (function() {
+            'use strict';
+
+            const API = window.location.origin;
+
+            function togglePassword() {
+                const passwordInput = document.getElementById('password');
+                const toggleBtn = document.getElementById('togglePassword');
+                
+                if (!passwordInput || !toggleBtn) return;
+                
+                if (passwordInput.type === 'password') {
+                    passwordInput.type = 'text';
+                    toggleBtn.textContent = '🙈';
+                } else {
+                    passwordInput.type = 'password';
+                    toggleBtn.textContent = '👁️';
+                }
+            }
+
+            function showError(message) {
+                const errorEl = document.getElementById('errorMessage');
+                const successEl = document.getElementById('successMessage');
+                
+                if (!errorEl) return;
+                
+                successEl.classList.remove('show');
+                errorEl.textContent = '❌ ' + message;
+                errorEl.classList.add('show');
+                
+                setTimeout(() => {
+                    errorEl.classList.remove('show');
+                }, 5000);
+            }
+
+            function showSuccess(message) {
+                const successEl = document.getElementById('successMessage');
+                const errorEl = document.getElementById('errorMessage');
+                
+                if (!successEl) return;
+                
+                errorEl.classList.remove('show');
+                successEl.textContent = '✅ ' + message;
+                successEl.classList.add('show');
+            }
+
+            async function sha256(message) {
+                try {
+                    const msgBuffer = new TextEncoder().encode(message);
+                    const hashBuffer = await crypto.subtle.digest('SHA-256', msgBuffer);
+                    const hashArray = Array.from(new Uint8Array(hashBuffer));
+                    return hashArray.map(b => b.toString(16).padStart(2, '0')).join('');
+                } catch (error) {
+                    throw error;
+                }
+            }
+
+            function clearAuth() {
+                localStorage.removeItem('admin_token');
+                localStorage.removeItem('admin_token_expiry');
+                localStorage.removeItem('admin_username');
+            }
+
+            function saveAuth(token, username) {
+                const expiry = Date.now() + (24 * 60 * 60 * 1000);
+                
+                localStorage.setItem('admin_token', token);
+                localStorage.setItem('admin_token_expiry', expiry.toString());
+                localStorage.setItem('admin_username', username);
+                
+            }
+
+            async function login(username, password) {
+                try {
+                    const passwordHash = await sha256(password);
+                    
+                    const response = await fetch(`${API}/api/admin/login`, {
+                        method: 'POST',
+                        headers: {
+                            'Content-Type': 'application/json'
+                        },
+                        body: JSON.stringify({
+                            username: username,
+                            password_hash: passwordHash
+                        })
+                    });
+
+
+                    if (!response.ok) {
+                        const error = await response.json();
+                        throw new Error(error.message || '登录失败');
+                    }
+
+                    const data = await response.json();
+                    
+                    if (data.success && data.token) {
+                        saveAuth(data.token, username);
+                        return true;
+                    } else {
+                        throw new Error('登录失败：未返回有效 token');
+                    }
+                } catch (error) {
+                    throw error;
+                }
+            }
+
+            async function checkAuthStatus() {
+                const token = localStorage.getItem('admin_token');
+                const expiry = localStorage.getItem('admin_token_expiry');
+                
+                if (!token || !expiry) {
+                    return false;
+                }
+
+                if (Date.now() > parseInt(expiry)) {
+                    clearAuth();
+                    return false;
+                }
+
+                try {
+                    const response = await fetch(`${API}/api/admin/check`, {
+                        headers: {
+                            'Authorization': `Bearer ${token}`
+                        }
+                    });
+
+                    if (response.ok) {
+                        const data = await response.json();
+                        if (data.authenticated) {
+                            return true;
+                        }
+                    }
+                    
+                    clearAuth();
+                    return false;
+                } catch (error) {
+                    clearAuth();
+                    return false;
+                }
+            }
+
+            function initialize() {
+                
+                const togglePasswordBtn = document.getElementById('togglePassword');
+                if (togglePasswordBtn) {
+                    togglePasswordBtn.addEventListener('click', togglePassword);
+                }
+
+                const loginForm = document.getElementById('loginForm');
+                if (loginForm) {
+                    loginForm.addEventListener('submit', async (e) => {
+                        e.preventDefault();
+
+                        const usernameInput = document.getElementById('username');
+                        const passwordInput = document.getElementById('password');
+                        const loginBtn = document.getElementById('loginBtn');
+
+                        if (!usernameInput || !passwordInput || !loginBtn) return;
+
+                        const username = usernameInput.value.trim();
+                        const password = passwordInput.value;
+
+                        if (!username || !password) {
+                            showError('请输入用户名和密码');
+                            return;
+                        }
+
+                        loginBtn.disabled = true;
+                        loginBtn.textContent = '验证中...';
+
+                        try {
+                            const success = await login(username, password);
+
+                            if (success) {
+                                showSuccess('登录成功！正在跳转...');
+                                
+                                setTimeout(() => {
+                                    window.location.href = '/admin';
+                                }, 1500);
+                            } else {
+                                showError('登录失败，请重试');
+                                loginBtn.disabled = false;
+                                loginBtn.textContent = '🚀 登录管理后台';
+                                passwordInput.value = '';
+                                passwordInput.focus();
+                            }
+                        } catch (error) {
+                            showError(error.message || '登录失败，请重试');
+                            loginBtn.disabled = false;
+                            loginBtn.textContent = '🚀 登录管理后台';
+                            passwordInput.value = '';
+                            passwordInput.focus();
+                        }
+                    });
+                }
+
+                checkAuthStatus().then(isValid => {
+                    if (isValid) {
+                        window.location.href = '/admin';
+                    } else {
+                    }
+                });
+
+                setTimeout(() => {
+                    const usernameInput = document.getElementById('username');
+                    if (usernameInput) {
+                        usernameInput.focus();
+                    }
+                }, 300);
+            }
+
+            if (document.readyState === 'loading') {
+                document.addEventListener('DOMContentLoaded', initialize);
+            } else {
+                initialize();
+            }
+
+        })();
+    </script>
+</body>
+</html>

static/admin.html

@@ -0,0 +1,1321 @@
+<!DOCTYPE html>
+<html lang="zh-CN">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>管理员后台 - Media Gateway</title>
+    <link rel="preconnect" href="https://fonts.googleapis.com">
+    <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>
+    <style>
+        @import url('https://fonts.googleapis.com/css2?family=Inter:wght@300;400;500;600;700;800&display=swap');
+
+        :root {
+            --primary: #6366f1;
+            --primary-dark: #4f46e5;
+            --primary-light: #818cf8;
+            --secondary: #ec4899;
+            --success: #10b981;
+            --warning: #f59e0b;
+            --danger: #ef4444;
+            --dark: #1e293b;
+            --light: #f8fafc;
+            --border: #e2e8f0;
+            --gradient-primary: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+            --gradient-success: linear-gradient(135deg, #10b981 0%, #059669 100%);
+            --gradient-warning: linear-gradient(135deg, #f59e0b 0%, #d97706 100%);
+            --gradient-danger: linear-gradient(135deg, #ef4444 0%, #dc2626 100%);
+            --shadow: 0 4px 15px rgba(0, 0, 0, 0.08);
+            --shadow-lg: 0 20px 60px rgba(0, 0, 0, 0.15);
+        }
+
+        * {
+            margin: 0;
+            padding: 0;
+            box-sizing: border-box;
+        }
+
+        body {
+            font-family: 'Inter', -apple-system, BlinkMacSystemFont, 'Segoe UI', sans-serif;
+            background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+            background-size: 200% 200%;
+            animation: gradientShift 15s ease infinite;
+            background-attachment: fixed;
+            min-height: 100vh;
+            padding: 20px;
+        }
+
+        @keyframes gradientShift {
+            0% { background-position: 0% 50%; }
+            50% { background-position: 100% 50%; }
+            100% { background-position: 0% 50%; }
+        }
+
+        @keyframes fadeIn {
+            from { opacity: 0; transform: translateY(20px); }
+            to { opacity: 1; transform: translateY(0); }
+        }
+
+        @keyframes scaleIn {
+            from { opacity: 0; transform: scale(0.95); }
+            to { opacity: 1; transform: scale(1); }
+        }
+
+        @keyframes spin {
+            to { transform: rotate(360deg); }
+        }
+
+        .loading-overlay {
+            position: fixed;
+            top: 0;
+            left: 0;
+            width: 100%;
+            height: 100%;
+            background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+            display: flex;
+            flex-direction: column;
+            align-items: center;
+            justify-content: center;
+            z-index: 99999;
+        }
+
+        .loading-overlay.hide {
+            display: none !important;
+        }
+
+        .loading-spinner-large {
+            width: 60px;
+            height: 60px;
+            border: 5px solid rgba(255,255,255,.2);
+            border-radius: 50%;
+            border-top-color: #fff;
+            animation: spin 1s linear infinite;
+        }
+
+        .loading-text {
+            color: white;
+            margin-top: 20px;
+            font-size: 1.2em;
+            font-weight: 600;
+        }
+
+        .container {
+            max-width: 1600px;
+            margin: 0 auto;
+            background: rgba(255, 255, 255, 0.95);
+            backdrop-filter: blur(20px);
+            border-radius: 30px;
+            box-shadow: var(--shadow-lg);
+            overflow: hidden;
+            display: none;
+            animation: scaleIn 0.6s ease;
+        }
+
+        .container.show {
+            display: block !important;
+        }
+
+        .header {
+            background: var(--gradient-primary);
+            color: white;
+            padding: 30px 40px;
+        }
+
+        .header-top {
+            display: flex;
+            justify-content: space-between;
+            align-items: center;
+            margin-bottom: 25px;
+            flex-wrap: wrap;
+            gap: 15px;
+        }
+
+        .header h1 {
+            font-size: 2.5em;
+            margin-bottom: 5px;
+            font-weight: 800;
+        }
+
+        .logout-btn {
+            padding: 12px 24px;
+            background: rgba(255, 255, 255, 0.2);
+            color: white;
+            border: 2px solid rgba(255, 255, 255, 0.5);
+            border-radius: 50px;
+            cursor: pointer;
+            font-size: 1em;
+            font-weight: 600;
+        }
+
+        .logout-btn:hover {
+            background: rgba(255, 255, 255, 0.3);
+        }
+
+        .stats-bar {
+            display: grid;
+            grid-template-columns: repeat(auto-fit, minmax(220px, 1fr));
+            gap: 20px;
+            padding: 30px 40px;
+            background: rgba(248, 250, 252, 0.8);
+        }
+
+        .stat-card {
+            background: white;
+            padding: 28px;
+            border-radius: 20px;
+            box-shadow: var(--shadow);
+            text-align: center;
+        }
+
+        .stat-card h3 {
+            color: #64748b;
+            font-size: 0.85em;
+            margin-bottom: 12px;
+            text-transform: uppercase;
+            letter-spacing: 1px;
+            font-weight: 700;
+        }
+
+        .stat-card .number {
+            font-size: 2.5em;
+            font-weight: 800;
+            background: var(--gradient-primary);
+            -webkit-background-clip: text;
+            -webkit-text-fill-color: transparent;
+        }
+
+        .content {
+            padding: 40px;
+        }
+
+        .section {
+            margin-bottom: 50px;
+        }
+
+        .section h2 {
+            margin-bottom: 25px;
+            color: var(--dark);
+            font-size: 1.8em;
+            font-weight: 700;
+        }
+
+        .form-grid {
+            display: grid;
+            grid-template-columns: 1fr 1fr;
+            gap: 20px;
+            margin-bottom: 25px;
+        }
+
+        .form-group {
+            margin-bottom: 20px;
+        }
+
+        .form-group label {
+            display: block;
+            margin-bottom: 8px;
+            font-weight: 600;
+            color: var(--dark);
+        }
+
+        .form-group input,
+        .form-group select {
+            width: 100%;
+            padding: 14px 18px;
+            border: 2px solid var(--border);
+            border-radius: 12px;
+            font-size: 0.95em;
+            font-family: inherit;
+        }
+
+        .form-group input:focus,
+        .form-group select:focus {
+            outline: none;
+            border-color: var(--primary);
+        }
+
+        .btn {
+            padding: 12px 24px;
+            border: none;
+            border-radius: 12px;
+            cursor: pointer;
+            font-size: 0.95em;
+            font-weight: 600;
+        }
+
+        .btn:hover:not(:disabled) {
+            opacity: 0.9;
+        }
+
+        .btn:disabled {
+            opacity: 0.6;
+            cursor: not-allowed;
+        }
+
+        .btn-primary {
+            background: var(--gradient-primary);
+            color: white;
+        }
+
+        .btn-success {
+            background: var(--gradient-success);
+            color: white;
+        }
+
+        .btn-warning {
+            background: var(--gradient-warning);
+            color: white;
+        }
+
+        .btn-danger {
+            background: var(--gradient-danger);
+            color: white;
+        }
+
+        .user-table {
+            width: 100%;
+            border-collapse: collapse;
+            margin-top: 20px;
+            background: white;
+            border-radius: 16px;
+            overflow: hidden;
+            box-shadow: var(--shadow);
+        }
+
+        .user-table th,
+        .user-table td {
+            padding: 16px;
+            text-align: left;
+            border-bottom: 1px solid var(--border);
+        }
+
+        .user-table th {
+            background: var(--gradient-primary);
+            color: white;
+            font-weight: 700;
+            text-transform: uppercase;
+            font-size: 0.8em;
+        }
+
+        .user-table tr:hover {
+            background: rgba(99, 102, 241, 0.05);
+        }
+
+        .badge {
+            padding: 6px 14px;
+            border-radius: 20px;
+            font-size: 0.8em;
+            font-weight: 700;
+            display: inline-block;
+        }
+
+        .badge-success {
+            background: linear-gradient(135deg, #d1fae5 0%, #a7f3d0 100%);
+            color: #065f46;
+        }
+
+        .badge-danger {
+            background: linear-gradient(135deg, #fee2e2 0%, #fecaca 100%);
+            color: #991b1b;
+        }
+
+        .badge-warning {
+            background: linear-gradient(135deg, #fef3c7 0%, #fde68a 100%);
+            color: #92400e;
+        }
+
+        .badge-admin {
+            background: linear-gradient(135deg, #f59e0b 0%, #ef4444 100%);
+            color: white;
+        }
+
+        .action-buttons {
+            display: flex;
+            gap: 8px;
+            flex-wrap: wrap;
+        }
+
+        .action-buttons .btn {
+            padding: 8px 14px;
+            font-size: 0.85em;
+        }
+
+        .user-badge {
+            display: inline-flex;
+            align-items: center;
+            gap: 5px;
+            padding: 4px 10px;
+            border-radius: 12px;
+            font-size: 0.8em;
+            font-weight: 700;
+        }
+
+        .badge-selector {
+            display: grid;
+            grid-template-columns: repeat(auto-fill, minmax(150px, 1fr));
+            gap: 12px;
+            margin-top: 15px;
+        }
+
+        .badge-option {
+            padding: 12px;
+            border: 2px solid var(--border);
+            border-radius: 12px;
+            cursor: pointer;
+            text-align: center;
+            transition: all 0.3s ease;
+        }
+
+        .badge-option:hover {
+            transform: translateY(-3px);
+        }
+
+        .badge-option.selected {
+            border-color: var(--primary);
+            box-shadow: 0 0 0 3px rgba(99, 102, 241, 0.1);
+        }
+
+        .badge-preview {
+            display: inline-flex;
+            align-items: center;
+            gap: 5px;
+            padding: 6px 12px;
+            border-radius: 12px;
+            font-size: 0.85em;
+            font-weight: 700;
+            margin-top: 8px;
+        }
+
+        .modal {
+            display: none;
+            position: fixed;
+            top: 0;
+            left: 0;
+            width: 100%;
+            height: 100%;
+            background: rgba(30, 41, 59, 0.8);
+            z-index: 9999;
+            align-items: center;
+            justify-content: center;
+        }
+
+        .modal.show {
+            display: flex;
+        }
+
+        .modal-content {
+            background: white;
+            padding: 35px;
+            border-radius: 24px;
+            max-width: 500px;
+            width: 90%;
+            max-height: 85vh;
+            overflow-y: auto;
+        }
+
+        .modal-header h2 {
+            color: var(--dark);
+            font-size: 1.8em;
+            font-weight: 700;
+            margin-bottom: 24px;
+        }
+
+        .modal-footer {
+            margin-top: 24px;
+            display: flex;
+            gap: 12px;
+            justify-content: flex-end;
+        }
+
+        .password-display {
+            background: linear-gradient(135deg, #dbeafe 0%, #bfdbfe 100%);
+            padding: 24px;
+            border-radius: 16px;
+            border: 2px dashed #3b82f6;
+            margin: 20px 0;
+            text-align: center;
+        }
+
+        .password-display .password {
+            font-size: 1.6em;
+            font-weight: 800;
+            color: #1e40af;
+            font-family: 'Courier New', monospace;
+            margin: 16px 0;
+            padding: 16px;
+            background: white;
+            border-radius: 12px;
+        }
+
+        .notification {
+            position: fixed;
+            top: 30px;
+            right: 30px;
+            padding: 18px 28px;
+            border-radius: 16px;
+            z-index: 10000;
+            color: white;
+            font-weight: 600;
+        }
+
+        .notification.success {
+            background: linear-gradient(135deg, #10b981 0%, #059669 100%);
+        }
+
+        .notification.error {
+            background: linear-gradient(135deg, #ef4444 0%, #dc2626 100%);
+        }
+
+        @media (max-width: 768px) {
+            .form-grid {
+                grid-template-columns: 1fr;
+            }
+        }
+    </style>
+</head>
+<body>
+    <div class="loading-overlay" id="loadingOverlay">
+        <div class="loading-spinner-large"></div>
+        <div class="loading-text">验证身份中...</div>
+    </div>
+
+    <div class="container" id="mainContainer">
+        <header class="header">
+            <div class="header-top">
+                <div>
+                    <h1>🔐 管理员后台</h1>
+                    <p>Media Gateway - User Management System</p>
+                </div>
+                <button class="logout-btn" id="logoutBtn">🚪 退出登录</button>
+            </div>
+        </header>
+
+        <div class="stats-bar">
+            <div class="stat-card">
+                <h3>总用户数</h3>
+                <div class="number" id="totalUsers">0</div>
+            </div>
+            <div class="stat-card">
+                <h3>活跃用户</h3>
+                <div class="number" id="activeUsers">0</div>
+            </div>
+            <div class="stat-card">
+                <h3>已过期</h3>
+                <div class="number" id="expiredUsers">0</div>
+            </div>
+            <div class="stat-card">
+                <h3>已禁用</h3>
+                <div class="number" id="inactiveUsers">0</div>
+            </div>
+        </div>
+
+        <div class="content">
+            <div class="section">
+                <h2>➕ 创建新用户</h2>
+                <form id="createUserForm">
+                    <div class="form-grid">
+                        <div class="form-group">
+                            <label for="username">👤 用户名 *</label>
+                            <input type="text" id="username" placeholder="请输入用户名" required>
+                        </div>
+                        <div class="form-group">
+                            <label for="password">🔒 密码（留空自动生成）</label>
+                            <input type="text" id="password" placeholder="留空则自动生成强密码">
+                        </div>
+                        <div class="form-group">
+                            <label for="expiryDays">⏰ 有效期（天）</label>
+                            <select id="expiryDays">
+                                <option value="">永久有效</option>
+                                <option value="7">7天</option>
+                                <option value="30" selected>30天</option>
+                                <option value="90">90天</option>
+                                <option value="180">180天</option>
+                                <option value="365">365天</option>
+                                <option value="custom">自定义天数</option>
+                            </select>
+                        </div>
+                        <div class="form-group" id="customDaysGroup" style="display: none;">
+                            <label for="customDays">🔢 自定义天数</label>
+                            <input type="number" id="customDays" placeholder="输入天数" min="1">
+                        </div>
+                        <!-- ✅ 用户类型选择 -->
+                        <div class="form-group">
+                            <label for="userType">👑 用户类型</label>
+                            <select id="userType">
+                                <option value="user" selected>👤 普通用户</option>
+                                <option value="admin">👑 管理员</option>
+                            </select>
+                        </div>
+                        <div class="form-group">
+                            <label for="notes">📝 备注信息</label>
+                            <input type="text" id="notes" placeholder="可选，添加备注信息">
+                        </div>
+                    </div>
+                    
+                    <div class="form-group">
+                        <label>🏷️ 用户徽章（可选）</label>
+                        <div class="badge-selector" id="badgeSelector">
+                            <div class="badge-option selected" data-badge="" onclick="selectBadge('')">
+                                <div style="font-size: 2em;">❌</div>
+                                <div style="margin-top: 5px; font-size: 0.85em;">无徽章</div>
+                            </div>
+                        </div>
+                        <input type="hidden" id="selectedBadge" value="">
+                    </div>
+                    
+                    <button type="submit" class="btn btn-primary" style="width: 100%; padding: 16px;">
+                        ➕ 创建用户
+                    </button>
+                </form>
+            </div>
+
+            <div class="section">
+                <h2>👥 用户列表</h2>
+                <button class="btn btn-success" onclick="loadUsers()" style="margin-bottom: 20px;">
+                    🔄 刷新列表
+                </button>
+                <div style="overflow-x: auto;">
+                    <table class="user-table">
+                        <thead>
+                            <tr>
+                                <th>用户名</th>
+                                <th>类型</th>
+                                <th>徽章</th>
+                                <th>创建时间</th>
+                                <th>过期时间</th>
+                                <th>最后登录</th>
+                                <th>状态</th>
+                                <th>备注</th>
+                                <th>操作</th>
+                            </tr>
+                        </thead>
+                        <tbody id="userTableBody">
+                            <tr>
+                                <td colspan="9" style="text-align: center; padding: 40px;">
+                                    <div class="loading-spinner-large" style="margin: 0 auto 15px;"></div>
+                                    <p>加载用户列表中...</p>
+                                </td>
+                            </tr>
+                        </tbody>
+                    </table>
+                </div>
+            </div>
+        </div>
+    </div>
+
+    <div class="modal" id="passwordModal">
+        <div class="modal-content">
+            <div class="modal-header">
+                <h2>✅ 用户创建成功</h2>
+            </div>
+            <div class="password-display">
+                <p><strong>用户名：</strong><span id="displayUsername"></span></p>
+                <p><strong>登录密码：</strong></p>
+                <div class="password" id="displayPassword"></div>
+                <button class="btn btn-primary" onclick="copyPassword()">
+                    📋 复制密码
+                </button>
+            </div>
+            <p style="color: var(--danger); font-weight: 700; margin-top: 16px;">
+                ⚠️ 请务必保��此密码！关闭后将无法再次查看。
+            </p>
+            <div class="modal-footer">
+                <button class="btn btn-primary" onclick="closePasswordModal()">
+                    我已保存密码
+                </button>
+            </div>
+        </div>
+    </div>
+
+    <div class="modal" id="badgeModal">
+        <div class="modal-content">
+            <div class="modal-header">
+                <h2>🏷️ 设置用户徽章</h2>
+            </div>
+            <p style="margin-bottom: 20px; color: #64748b;">
+                为用户 <strong id="badgeUsername"></strong> 选择徽章
+            </p>
+            <div class="badge-selector" id="badgeSelectorModal"></div>
+            <div class="modal-footer">
+                <button class="btn btn-primary" onclick="confirmBadge()">
+                    ✅ 确认设置
+                </button>
+                <button class="btn" onclick="closeBadgeModal()" style="background: #94a3b8; color: white;">
+                    取消
+                </button>
+            </div>
+        </div>
+    </div>
+
+    <script>
+        (function() {
+            'use strict';
+
+            const API = window.location.origin;
+            let availableBadges = {};
+            let currentBadgeUsername = '';
+            let selectedModalBadge = '';
+
+            function getAdminToken() {
+                const token = localStorage.getItem('admin_token');
+                return token;
+            }
+
+            function getTokenExpiry() {
+                const expiry = localStorage.getItem('admin_token_expiry');
+                return expiry ? parseInt(expiry) : 0;
+            }
+
+            function clearAuth() {
+                localStorage.removeItem('admin_token');
+                localStorage.removeItem('admin_token_expiry');
+                localStorage.removeItem('admin_username');
+            }
+
+            async function checkAuth() {
+                const token = getAdminToken();
+                const expiry = getTokenExpiry();
+                
+                if (!token) {
+                    return false;
+                }
+
+                if (Date.now() > expiry) {
+                    clearAuth();
+                    return false;
+                }
+
+                try {
+                    const response = await fetch(`${API}/api/admin/check`, {
+                        method: 'GET',
+                        headers: {
+                            'Authorization': `Bearer ${token}`
+                        }
+                    });
+
+                    if (!response.ok) {
+                        clearAuth();
+                        return false;
+                    }
+
+                    const data = await response.json();
+                    
+                    if (data.authenticated === true) {
+                        return true;
+                    }
+                    
+                    clearAuth();
+                    return false;
+                    
+                } catch (error) {
+                    clearAuth();
+                    return false;
+                }
+            }
+
+            function redirectToLogin() {
+                setTimeout(() => {
+                    window.location.href = '/admin/login';
+                }, 1000);
+            }
+
+            function logout() {
+                if (confirm('确定要退出登录吗？')) {
+                    clearAuth();
+                    redirectToLogin();
+                }
+            }
+
+            function showNotification(message, type = 'success') {
+                const notification = document.createElement('div');
+                notification.className = `notification ${type}`;
+                notification.textContent = message;
+                document.body.appendChild(notification);
+                
+                setTimeout(() => {
+                    notification.remove();
+                }, 3000);
+            }
+
+            function showLoading(text = '验证身份中...') {
+                const overlay = document.getElementById('loadingOverlay');
+                const loadingText = overlay?.querySelector('.loading-text');
+                if (overlay) {
+                    overlay.classList.remove('hide');
+                    if (loadingText) loadingText.textContent = text;
+                }
+            }
+
+            function hideLoading() {
+                const overlay = document.getElementById('loadingOverlay');
+                if (overlay) overlay.classList.add('hide');
+                
+                const container = document.getElementById('mainContainer');
+                if (container) container.classList.add('show');
+            }
+
+            async function loadBadges() {
+                try {
+                    const token = getAdminToken();
+                    const response = await fetch(`${API}/api/admin/badges`, {
+                        headers: { 'Authorization': `Bearer ${token}` }
+                    });
+
+                    if (response.ok) {
+                        const data = await response.json();
+                        availableBadges = data.badges || {};
+                        renderBadgeSelector();
+                    }
+                } catch (error) {
+                }
+            }
+
+            function renderBadgeSelector() {
+                const selector = document.getElementById('badgeSelector');
+                if (!selector) return;
+
+                let html = `
+                    <div class="badge-option selected" data-badge="" onclick="selectBadge('')">
+                        <div style="font-size: 2em;">❌</div>
+                        <div style="margin-top: 5px; font-size: 0.85em;">无徽章</div>
+                    </div>
+                `;
+
+                for (const [id, badge] of Object.entries(availableBadges)) {
+                    html += `
+                        <div class="badge-option" data-badge="${id}" onclick="selectBadge('${id}')">
+                            <div style="font-size: 2em;">${badge.icon}</div>
+                            <div class="badge-preview" style="
+                                background: ${badge.gradient};
+                                color: ${badge.color};
+                                border: 2px solid ${badge.border};
+                                box-shadow: 0 2px 8px ${badge.glow};
+                            ">
+                                ${badge.name}
+                            </div>
+                        </div>
+                    `;
+                }
+
+                selector.innerHTML = html;
+            }
+
+            window.selectBadge = function(badgeId) {
+                const options = document.querySelectorAll('#badgeSelector .badge-option');
+                options.forEach(opt => {
+                    opt.classList.toggle('selected', opt.dataset.badge === badgeId);
+                });
+                document.getElementById('selectedBadge').value = badgeId;
+            };
+
+            window.openBadgeModal = function(username) {
+                currentBadgeUsername = username;
+                document.getElementById('badgeUsername').textContent = username;
+                
+                const modalSelector = document.getElementById('badgeSelectorModal');
+                if (!modalSelector) return;
+
+                let html = `
+                    <div class="badge-option selected" data-badge="" onclick="selectModalBadge('')">
+                        <div style="font-size: 2em;">❌</div>
+                        <div style="margin-top: 5px; font-size: 0.85em;">无徽章</div>
+                    </div>
+                `;
+
+                for (const [id, badge] of Object.entries(availableBadges)) {
+                    html += `
+                        <div class="badge-option" data-badge="${id}" onclick="selectModalBadge('${id}')">
+                            <div style="font-size: 2em;">${badge.icon}</div>
+                            <div class="badge-preview" style="
+                                background: ${badge.gradient};
+                                color: ${badge.color};
+                                border: 2px solid ${badge.border};
+                                box-shadow: 0 2px 8px ${badge.glow};
+                            ">
+                                ${badge.name}
+                            </div>
+                        </div>
+                    `;
+                }
+
+                modalSelector.innerHTML = html;
+                selectedModalBadge = '';
+                document.getElementById('badgeModal').classList.add('show');
+            };
+
+            window.selectModalBadge = function(badgeId) {
+                const options = document.querySelectorAll('#badgeSelectorModal .badge-option');
+                options.forEach(opt => {
+                    opt.classList.toggle('selected', opt.dataset.badge === badgeId);
+                });
+                selectedModalBadge = badgeId;
+            };
+
+            window.confirmBadge = async function() {
+                if (!currentBadgeUsername) {
+                    showNotification('⚠️ 未选择用户', 'error');
+                    return;
+                }
+
+                const token = getAdminToken();
+
+                if (!token) {
+                    showNotification('⚠️ 未登录，请重新登录', 'error');
+                    setTimeout(() => {
+                        window.location.href = '/admin/login';
+                    }, 1500);
+                    return;
+                }
+
+                try {
+                    const response = await fetch(`${API}/api/admin/users/${currentBadgeUsername}/badge`, {
+                        method: 'POST',
+                        headers: {
+                            'Authorization': `Bearer ${token}`,
+                            'Content-Type': 'application/json'
+                        },
+                        body: JSON.stringify({
+                            badge: selectedModalBadge || null
+                        })
+                    });
+
+                    if (response.status === 401) {
+                        clearAuth();
+                        showNotification('❌ 登录已过期，请重新登录', 'error');
+                        setTimeout(() => {
+                            window.location.href = '/admin/login';
+                        }, 1500);
+                        return;
+                    }
+
+                    if (!response.ok) {
+                        const errorData = await response.json();
+                        throw new Error(errorData.error || '设置失败');
+                    }
+
+                    const data = await response.json();
+
+                    showNotification('✅ 徽章设置成功', 'success');
+                    closeBadgeModal();
+                    await loadUsers();
+                } catch (error) {
+                    showNotification('❌ 设置徽章失败: ' + error.message, 'error');
+                }
+            };
+
+            window.closeBadgeModal = function() {
+                document.getElementById('badgeModal').classList.remove('show');
+                currentBadgeUsername = '';
+                selectedModalBadge = '';
+            };
+
+            async function loadStats() {
+                const token = getAdminToken();
+                
+                try {
+                    const response = await fetch(`${API}/api/admin/stats`, {
+                        headers: { 'Authorization': `Bearer ${token}` }
+                    });
+
+                    if (response.ok) {
+                        const data = await response.json();
+                        document.getElementById('totalUsers').textContent = data.total || 0;
+                        document.getElementById('activeUsers').textContent = data.active || 0;
+                        document.getElementById('expiredUsers').textContent = data.expired || 0;
+                        document.getElementById('inactiveUsers').textContent = data.inactive || 0;
+                    }
+                } catch (error) {
+                }
+            }
+
+            async function loadUsers() {
+                const token = getAdminToken();
+                const tbody = document.getElementById('userTableBody');
+                
+                tbody.innerHTML = `
+                    <tr>
+                        <td colspan="9" style="text-align: center; padding: 40px;">
+                            <div class="loading-spinner-large" style="margin: 0 auto 15px;"></div>
+                            <p>加载中...</p>
+                        </td>
+                    </tr>
+                `;
+                
+                try {
+                    const response = await fetch(`${API}/api/admin/users`, {
+                        headers: { 'Authorization': `Bearer ${token}` }
+                    });
+
+                    if (!response.ok) {
+                        throw new Error(`HTTP ${response.status}`);
+                    }
+
+                    const data = await response.json();
+                    
+                    renderUsers(data.users);
+                    await loadStats();
+                    showNotification('✅ 用户列表已刷新', 'success');
+                } catch (error) {
+                    tbody.innerHTML = `
+                        <tr>
+                            <td colspan="9" style="text-align: center; padding: 40px; color: #ef4444;">
+                                ❌ 加载失败: ${error.message}
+                            </td>
+                        </tr>
+                    `;
+                    showNotification('❌ 加载用户列表失败', 'error');
+                }
+            }
+
+            function renderUsers(users) {
+                const tbody = document.getElementById('userTableBody');
+                
+                if (!users || users.length === 0) {
+                    tbody.innerHTML = `
+                        <tr>
+                            <td colspan="9" style="text-align: center; padding: 40px;">
+                                <div style="font-size: 3em; margin-bottom: 15px;">👥</div>
+                                <p style="font-weight: 600;">暂无用户</p>
+                            </td>
+                        </tr>
+                    `;
+                    return;
+                }
+
+                tbody.innerHTML = users.map(user => {
+                    const createdAt = new Date(user.created_at).toLocaleString('zh-CN');
+                    const expiresAt = user.expires_at ? new Date(user.expires_at).toLocaleString('zh-CN') : '永久';
+                    const lastLogin = user.last_login ? new Date(user.last_login).toLocaleString('zh-CN') : '从未登录';
+                    
+                    // ✅ 用户类型显示
+                    const userTypeBadge = user.is_admin 
+                        ? '<span class="badge badge-admin">👑 管理员</span>'
+                        : '<span class="badge badge-success">👤 普通用户</span>';
+                    
+                    let statusBadge = '';
+                    if (!user.is_active) {
+                        statusBadge = '<span class="badge badge-danger">已禁用</span>';
+                    } else if (user.expires_at && new Date(user.expires_at) < new Date()) {
+                        statusBadge = '<span class="badge badge-warning">已过期</span>';
+                    } else {
+                        statusBadge = '<span class="badge badge-success">正常</span>';
+                    }
+
+                    let userBadgeHtml = '-';
+                    if (user.badge && availableBadges[user.badge]) {
+                        const badge = availableBadges[user.badge];
+                        userBadgeHtml = `
+                            <div class="user-badge" style="
+                                background: ${badge.gradient};
+                                color: ${badge.color};
+                                border: 2px solid ${badge.border};
+                                box-shadow: 0 2px 8px ${badge.glow};
+                            ">
+                                <span>${badge.icon}</span>
+                                <span>${badge.name}</span>
+                            </div>
+                        `;
+                    }
+
+                    return `
+                        <tr>
+                            <td><strong>${user.username}</strong></td>
+                            <td>${userTypeBadge}</td>
+                            <td>${userBadgeHtml}</td>
+                            <td>${createdAt}</td>
+                            <td>${expiresAt}</td>
+                            <td>${lastLogin}</td>
+                            <td>${statusBadge}</td>
+                            <td>${user.notes || '-'}</td>
+                            <td>
+                                <div class="action-buttons">
+                                    <button class="btn btn-primary" onclick="openBadgeModal('${user.username}')">🏷️</button>
+                                    ${user.is_active ? 
+                                        `<button class="btn btn-warning" onclick="toggleUser('${user.username}', false)">禁用</button>` :
+                                        `<button class="btn btn-success" onclick="toggleUser('${user.username}', true)">启用</button>`
+                                    }
+                                    <button class="btn btn-primary" onclick="extendExpiry('${user.username}')">续期</button>
+                                    <button class="btn btn-danger" onclick="deleteUser('${user.username}')">删除</button>
+                                </div>
+                            </td>
+                        </tr>
+                    `;
+                }).join('');
+            }
+
+            async function createUser(username, password, expiryDays, notes, badge, isAdmin) {
+                const token = getAdminToken();
+                
+                const response = await fetch(`${API}/api/admin/users`, {
+                    method: 'POST',
+                    headers: {
+                        'Authorization': `Bearer ${token}`,
+                        'Content-Type': 'application/json'
+                    },
+                    body: JSON.stringify({
+                        username,
+                        password: password || null,
+                        expires_days: expiryDays ? parseInt(expiryDays) : null,
+                        notes,
+                        badge: badge || null,
+                        is_admin: isAdmin  // ✅ 添加管理员标识
+                    })
+                });
+
+                if (!response.ok) {
+                    const error = await response.json();
+                    throw new Error(error.error || '创建失败');
+                }
+
+                return await response.json();
+            }
+
+            window.toggleUser = async function(username, activate) {
+                const token = getAdminToken();
+
+                if (!token) {
+                    showNotification('⚠️ 未登录，请重新登录', 'error');
+                    setTimeout(() => window.location.href = '/admin/login', 1500);
+                    return;
+                }
+
+                const action = activate ? 'activate' : 'deactivate';
+                const actionText = activate ? '启用' : '禁用';
+
+                if (!confirm(`确定要${actionText}用户 ${username} 吗？`)) return;
+
+                try {
+                    const response = await fetch(`${API}/api/admin/users/${username}/${action}`, {
+                        method: 'POST',
+                        headers: {
+                            'Authorization': `Bearer ${token}`,
+                            'Content-Type': 'application/json'
+                        }
+                    });
+
+                    if (response.status === 401) {
+                        clearAuth();
+                        showNotification('❌ 登录已过期，请重新登录', 'error');
+                        setTimeout(() => window.location.href = '/admin/login', 1500);
+                        return;
+                    }
+
+                    if (response.ok) {
+                        showNotification(`✅ 用户已${actionText}`, 'success');
+                        await loadUsers();
+                    } else {
+                        const errorData = await response.json();
+                        throw new Error(errorData.error || `${actionText}失败`);
+                    }
+                } catch (error) {
+                    showNotification(`❌ ${error.message}`, 'error');
+                }
+            };
+
+            window.deleteUser = async function(username) {
+                if (!confirm(`⚠️ 确定要删除用户 ${username} 吗？\n\n此操作不可恢复！`)) return;
+
+                const token = getAdminToken();
+
+                if (!token) {
+                    showNotification('⚠️ 未登录，请重新登录', 'error');
+                    setTimeout(() => window.location.href = '/admin/login', 1500);
+                    return;
+                }
+
+                try {
+                    const response = await fetch(`${API}/api/admin/users/${username}`, {
+                        method: 'DELETE',
+                        headers: {
+                            'Authorization': `Bearer ${token}`,
+                            'Content-Type': 'application/json'
+                        }
+                    });
+
+                    if (response.status === 401) {
+                        clearAuth();
+                        showNotification('❌ 登录已过期，请重新登录', 'error');
+                        setTimeout(() => window.location.href = '/admin/login', 1500);
+                        return;
+                    }
+
+                    if (response.ok) {
+                        showNotification('✅ 用户已删除', 'success');
+                        await loadUsers();
+                    } else {
+                        const errorData = await response.json();
+                        throw new Error(errorData.error || '删除失败');
+                    }
+                } catch (error) {
+                    showNotification(`❌ ${error.message}`, 'error');
+                }
+            };
+
+            window.extendExpiry = async function(username) {
+                const days = prompt('请输入要延长的天数:', '30');
+                if (!days || isNaN(days) || parseInt(days) <= 0) return;
+
+                const token = getAdminToken();
+
+                if (!token) {
+                    showNotification('⚠️ 未登录，请重新登录', 'error');
+                    setTimeout(() => window.location.href = '/admin/login', 1500);
+                    return;
+                }
+
+                try {
+                    const response = await fetch(`${API}/api/admin/users/${username}/extend`, {
+                        method: 'POST',
+                        headers: {
+                            'Authorization': `Bearer ${token}`,
+                            'Content-Type': 'application/json'
+                        },
+                        body: JSON.stringify({ days: parseInt(days) })
+                    });
+
+                    if (response.status === 401) {
+                        clearAuth();
+                        showNotification('❌ 登录已过期，请重新登录', 'error');
+                        setTimeout(() => window.location.href = '/admin/login', 1500);
+                        return;
+                    }
+
+                    if (response.ok) {
+                        showNotification(`✅ 已为用户 ${username} 延长 ${days} 天`, 'success');
+                        await loadUsers();
+                    } else {
+                        const errorData = await response.json();
+                        throw new Error(errorData.error || '续期失败');
+                    }
+                } catch (error) {
+                    showNotification(`❌ ${error.message}`, 'error');
+                }
+            };
+
+            window.copyPassword = function() {
+                const password = document.getElementById('displayPassword').textContent;
+                navigator.clipboard.writeText(password).then(() => {
+                    showNotification('✅ 密码已复制', 'success');
+                }).catch(() => {
+                    showNotification('❌ 复制失败', 'error');
+                });
+            };
+
+            window.closePasswordModal = function() {
+                document.getElementById('passwordModal').classList.remove('show');
+            };
+
+            window.loadUsers = loadUsers;
+
+            function handleCreateUserForm() {
+                const form = document.getElementById('createUserForm');
+                if (!form) return;
+
+                // ✅ 处理自定义天数显示/隐藏
+                const expiryDays = document.getElementById('expiryDays');
+                const customDaysGroup = document.getElementById('customDaysGroup');
+                
+                if (expiryDays) {
+                    expiryDays.addEventListener('change', (e) => {
+                        if (e.target.value === 'custom') {
+                            customDaysGroup.style.display = 'block';
+                        } else {
+                            customDaysGroup.style.display = 'none';
+                        }
+                    });
+                }
+
+                form.addEventListener('submit', async (e) => {
+                    e.preventDefault();
+
+                    const username = document.getElementById('username').value.trim();
+                    const password = document.getElementById('password').value.trim();
+                    let expiryDaysValue = document.getElementById('expiryDays').value;
+                    const notes = document.getElementById('notes').value.trim();
+                    const badge = document.getElementById('selectedBadge').value;
+                    const userType = document.getElementById('userType').value;
+
+                    // ✅ 处理自定义天数
+                    if (expiryDaysValue === 'custom') {
+                        const customDays = document.getElementById('customDays').value;
+                        if (!customDays || parseInt(customDays) <= 0) {
+                            showNotification('⚠️ 请输入有效的自定义天数', 'error');
+                            return;
+                        }
+                        expiryDaysValue = customDays;
+                    }
+
+                    if (!username) {
+                        showNotification('⚠️ 请输入用户名', 'error');
+                        return;
+                    }
+
+                    const submitBtn = form.querySelector('button[type="submit"]');
+                    const originalText = submitBtn.textContent;
+                    submitBtn.disabled = true;
+                    submitBtn.textContent = '创建中...';
+
+                    try {
+                        const isAdmin = userType === 'admin';
+                        const data = await createUser(username, password, expiryDaysValue, notes, badge, isAdmin);
+                        
+                        document.getElementById('displayUsername').textContent = username;
+                        document.getElementById('displayPassword').textContent = data.password;
+                        document.getElementById('passwordModal').classList.add('show');
+
+                        form.reset();
+                        selectBadge('');
+                        
+                        await loadUsers();
+                        showNotification('✅ 用户创建成功', 'success');
+                    } catch (error) {
+                        showNotification(`❌ 创建失败: ${error.message}`, 'error');
+                    } finally {
+                        submitBtn.disabled = false;
+                        submitBtn.textContent = originalText;
+                    }
+                });
+            }
+
+            async function initialize() {
+                showLoading('验证身份中...');
+
+                try {
+                    const isAuthenticated = await checkAuth();
+                    
+                    if (!isAuthenticated) {
+                        showLoading('未登录，正在跳转...');
+                        redirectToLogin();
+                        return;
+                    }
+
+                    const logoutBtn = document.getElementById('logoutBtn');
+                    if (logoutBtn) {
+                        logoutBtn.addEventListener('click', logout);
+                    }
+
+                    handleCreateUserForm();
+
+                    showLoading('加载数据...');
+                    
+                    await loadBadges();
+                    await loadUsers();
+
+                    hideLoading();
+                    
+                } catch (error) {
+                    showLoading('初始化失败...');
+                    setTimeout(() => {
+                        window.location.reload();
+                    }, 2000);
+                }
+            }
+
+            if (document.readyState === 'loading') {
+                document.addEventListener('DOMContentLoaded', initialize);
+            } else {
+                initialize();
+            }
+
+        })();
+    </script>
+</body>
+</html>

static/css/style.css

@@ -0,0 +1,1157 @@
+@import url('https://fonts.googleapis.com/css2?family=Inter:wght@400;500;600;700&display=swap');
+
+@keyframes shimmer {
+    0% { background-position: -468px 0; }
+    100% { background-position: 468px 0; }
+}
+
+.skeleton {
+    background: linear-gradient(90deg, #f0f0f0 25%, #e0e0e0 50%, #f0f0f0 75%);
+    background-size: 468px 100%;
+    animation: shimmer 1.2s ease-in-out infinite;
+    border-radius: 8px;
+}
+
+.skeleton-text { height: 16px; margin-bottom: 8px; }
+.skeleton-title { height: 24px; width: 60%; margin-bottom: 12px; }
+
+/* 性能优化 */
+.notification, .modal-overlay, .loading-overlay {
+    will-change: opacity, transform;
+    transform: translateZ(0);
+}
+
+.channel-item, .epg-item {
+    contain: layout style paint;
+}
+
+/* 优化动画 */
+.fab-button {
+    transition: transform 0.3s cubic-bezier(0.4, 0, 0.2, 1);
+}
+
+.fab-button:hover {
+    transform: translateY(-4px);
+}
+
+:root {
+    --primary: #6366f1;
+    --primary-dark: #4f46e5;
+    --success: #10b981;
+    --warning: #f59e0b;
+    --danger: #ef4444;
+    --dark: #1e293b;
+    --light: #f8fafc;
+    --border: #e2e8f0;
+    --shadow: 0 2px 8px rgba(0, 0, 0, 0.1);
+}
+
+* {
+    margin: 0;
+    padding: 0;
+    box-sizing: border-box;
+}
+
+body {
+    font-family: 'Inter', -apple-system, sans-serif;
+    background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+    background-attachment: fixed;
+    min-height: 100vh;
+    line-height: 1.5;
+    font-size: 14px;
+    color: var(--dark);
+    -webkit-font-smoothing: antialiased;
+}
+
+*, *::before, *::after {
+    animation: none !important;
+    transition: none !important;
+}
+
+.notification,
+.login-overlay,
+.epg-video-modal {
+    transition: opacity 0.15s ease !important;
+}
+
+.app-container {
+    display: flex;
+    flex-direction: column;
+    min-height: 100vh;
+    max-width: 1600px;
+    margin: 20px auto;
+    background: rgba(255, 255, 255, 0.95);
+    border-radius: 20px;
+    box-shadow: var(--shadow);
+    overflow: hidden;
+    contain: layout style paint;
+}
+
+.app-body {
+    flex: 1;
+    padding: 20px 30px;
+    transform: translateZ(0);
+    will-change: scroll-position;
+}
+
+.header {
+    background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+    color: white;
+    padding: 20px 30px;
+    contain: layout style paint;
+}
+
+.header-top {
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    margin-bottom: 15px;
+    gap: 15px;
+    flex-wrap: wrap;
+}
+
+.header h1 {
+    font-size: 1.8em;
+    font-weight: 700;
+    margin-bottom: 5px;
+}
+
+.subtitle {
+    font-size: 0.9em;
+    opacity: 0.9;
+}
+
+.status-bar {
+    display: flex;
+    justify-content: center;
+    gap: 20px;
+    flex-wrap: wrap;
+    font-size: 0.85em;
+}
+
+.status-item {
+    background: rgba(255, 255, 255, 0.2);
+    padding: 8px 15px;
+    border-radius: 20px;
+    display: flex;
+    align-items: center;
+    gap: 8px;
+    border: 1px solid rgba(255, 255, 255, 0.3);
+}
+
+.btn-logout {
+    padding: 10px 20px;
+    background: rgba(255, 255, 255, 0.2);
+    color: white;
+    border: 2px solid rgba(255, 255, 255, 0.5);
+    border-radius: 20px;
+    cursor: pointer;
+    font-size: 0.9em;
+    font-weight: 600;
+}
+
+.btn-logout:hover {
+    background: rgba(255, 255, 255, 0.3);
+}
+
+.user-type-badge {
+    display: inline-block;
+    padding: 3px 10px;
+    border-radius: 15px;
+    font-size: 0.7em;
+    font-weight: 700;
+    margin-left: 8px;
+}
+
+.user-type-badge.admin {
+    background: linear-gradient(135deg, #f59e0b 0%, #ef4444 100%);
+    color: white;
+}
+
+.user-type-badge.user {
+    background: linear-gradient(135deg, #3b82f6 0%, #8b5cf6 100%);
+    color: white;
+}
+
+.tabs {
+    display: flex;
+    background: rgba(248, 250, 252, 0.8);
+    border-bottom: 1px solid var(--border);
+    overflow-x: auto;
+    scrollbar-width: none;
+    contain: layout style;
+}
+
+.tabs::-webkit-scrollbar {
+    display: none;
+}
+
+.tab-button {
+    flex: 1;
+    padding: 15px 18px;
+    background: transparent;
+    border: none;
+    cursor: pointer;
+    font-size: 0.9em;
+    color: var(--dark);
+    font-weight: 500;
+    text-decoration: none;
+    text-align: center;
+    min-width: 120px;
+    border-bottom: 3px solid transparent;
+}
+
+.tab-button:hover {
+    background: rgba(99, 102, 241, 0.05);
+}
+
+.tab-button.active {
+    background: white;
+    font-weight: 600;
+    color: var(--primary);
+    border-bottom-color: var(--primary);
+}
+
+.btn {
+    padding: 10px 20px;
+    border: none;
+    border-radius: 10px;
+    cursor: pointer;
+    font-size: 0.9em;
+    font-weight: 600;
+    contain: layout style paint;
+}
+
+.btn:hover:not(:disabled) {
+    opacity: 0.9;
+}
+
+.btn:disabled {
+    opacity: 0.6;
+    cursor: not-allowed;
+}
+
+.btn-primary {
+    background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+    color: white;
+}
+
+.btn-success {
+    background: linear-gradient(135deg, #10b981 0%, #059669 100%);
+    color: white;
+}
+
+.btn-warning {
+    background: linear-gradient(135deg, #f59e0b 0%, #d97706 100%);
+    color: white;
+}
+
+.btn-danger {
+    background: linear-gradient(135deg, #ef4444 0%, #dc2626 100%);
+    color: white;
+}
+
+.form-control {
+    width: 100%;
+    padding: 12px 15px;
+    border: 2px solid var(--border);
+    border-radius: 10px;
+    font-size: 0.9em;
+    background: white;
+    font-family: inherit;
+}
+
+.form-control:focus {
+    outline: none;
+    border-color: var(--primary);
+}
+
+.form-group {
+    margin-bottom: 15px;
+}
+
+.form-group label {
+    display: block;
+    margin-bottom: 6px;
+    font-weight: 600;
+    color: var(--dark);
+    font-size: 0.85em;
+}
+
+.section-header {
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    margin-bottom: 20px;
+    gap: 15px;
+    flex-wrap: wrap;
+}
+
+.stats-box {
+    background: rgba(99, 102, 241, 0.1);
+    padding: 12px 20px;
+    border-radius: 12px;
+    margin-bottom: 20px;
+    font-size: 0.9em;
+    border: 1px solid rgba(99, 102, 241, 0.2);
+}
+
+.channel-grid {
+    display: grid;
+    grid-template-columns: repeat(auto-fill, minmax(220px, 1fr));
+    gap: 15px;
+    content-visibility: auto;
+}
+
+.channel-card {
+    background: white;
+    border: 2px solid transparent;
+    border-radius: 15px;
+    padding: 20px 15px;
+    cursor: pointer;
+    box-shadow: 0 2px 8px rgba(0, 0, 0, 0.08);
+    contain: layout style paint;
+    content-visibility: auto;
+}
+
+.channel-card:hover {
+    border-color: var(--primary);
+    box-shadow: 0 4px 12px rgba(99, 102, 241, 0.2);
+}
+
+.channel-name {
+    font-size: 1em;
+    color: var(--dark);
+    margin-bottom: 12px;
+    font-weight: 600;
+    text-align: center;
+    min-height: 45px;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+}
+
+.channel-actions {
+    display: flex;
+    gap: 8px;
+}
+
+.channel-actions .btn {
+    flex: 1;
+    padding: 8px;
+    font-size: 0.85em;
+}
+
+.player-page {
+    display: flex;
+    flex-direction: column;
+    gap: 15px;
+}
+
+.player-controls {
+    display: grid;
+    grid-template-columns: 1fr auto;
+    gap: 12px;
+    align-items: end;
+}
+
+.video-wrapper {
+    position: relative;
+    background: #1e293b;
+    border-radius: 15px;
+    overflow: hidden;
+    aspect-ratio: 16 / 9;
+    max-height: 550px;
+    contain: layout style;
+}
+
+video {
+    width: 100%;
+    height: 100%;
+    display: block;
+    object-fit: contain;
+}
+
+.video-placeholder {
+    position: absolute;
+    top: 0;
+    left: 0;
+    width: 100%;
+    height: 100%;
+    background: #1e293b;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    color: white;
+}
+
+.video-placeholder.hidden {
+    display: none;
+}
+
+.placeholder-icon {
+    font-size: 50px;
+    margin-bottom: 12px;
+    opacity: 0.6;
+}
+
+.stream-info-panel {
+    display: grid;
+    grid-template-columns: 1fr 1fr;
+    gap: 15px;
+}
+
+.info-section,
+.record-section {
+    background: rgba(255, 255, 255, 0.95);
+    padding: 20px;
+    border-radius: 15px;
+    box-shadow: 0 2px 8px rgba(0, 0, 0, 0.1);
+    contain: layout style paint;
+}
+
+.info-section h3,
+.record-section h3 {
+    margin-bottom: 12px;
+    color: var(--dark);
+    font-size: 1em;
+    font-weight: 700;
+}
+
+.info-content {
+    background: #f8fafc;
+    padding: 12px;
+    border-radius: 10px;
+    font-family: 'Courier New', monospace;
+    font-size: 0.8em;
+    line-height: 1.5;
+    white-space: pre-wrap;
+    word-break: break-all;
+    min-height: 100px;
+    max-height: 250px;
+    overflow-y: auto;
+    border: 1px solid #e2e8f0;
+    color: var(--dark);
+}
+
+.btn-record {
+    width: 100%;
+    padding: 14px;
+    background: linear-gradient(135deg, #ef4444 0%, #dc2626 100%);
+    color: white;
+    border: none;
+    border-radius: 12px;
+    cursor: pointer;
+    font-size: 0.95em;
+    font-weight: 700;
+}
+
+.btn-record:hover:not(:disabled) {
+    opacity: 0.9;
+}
+
+.btn-record:disabled {
+    background: linear-gradient(135deg, #94a3b8 0%, #64748b 100%);
+    cursor: not-allowed;
+}
+
+.record-status {
+    margin-top: 12px;
+    padding: 12px;
+    border-radius: 10px;
+    font-size: 0.85em;
+    text-align: center;
+    display: none;
+}
+
+.record-status.show {
+    display: block;
+}
+
+.record-status.recording {
+    background: linear-gradient(135deg, #fef3c7 0%, #fde68a 100%);
+    color: #92400e;
+    border: 2px solid #fbbf24;
+}
+
+.record-status.success {
+    background: linear-gradient(135deg, #d1fae5 0%, #a7f3d0 100%);
+    color: #065f46;
+    border: 2px solid #10b981;
+}
+
+.record-status.error {
+    background: linear-gradient(135deg, #fee2e2 0%, #fecaca 100%);
+    color: #991b1b;
+    border: 2px solid #ef4444;
+}
+
+.record-info {
+    background: rgba(219, 234, 254, 0.5);
+    padding: 12px;
+    border-radius: 10px;
+    margin-top: 12px;
+    font-size: 0.85em;
+    line-height: 1.5;
+}
+
+.epg-page {
+    display: flex;
+    flex-direction: column;
+    gap: 15px;
+}
+
+.epg-controls {
+    display: grid;
+    grid-template-columns: 1fr 1fr auto;
+    gap: 12px;
+    align-items: end;
+}
+
+.epg-list {
+    max-height: 550px;
+    overflow-y: auto;
+    background: rgba(248, 250, 252, 0.5);
+    border-radius: 15px;
+    padding: 15px;
+    content-visibility: auto;
+}
+
+.epg-item {
+    background: white;
+    padding: 15px;
+    margin-bottom: 12px;
+    border-radius: 12px;
+    border-left: 4px solid var(--primary);
+    box-shadow: 0 2px 8px rgba(0, 0, 0, 0.08);
+    contain: layout style paint;
+    content-visibility: auto;
+}
+
+.epg-item:hover {
+    box-shadow: 0 4px 12px rgba(99, 102, 241, 0.15);
+}
+
+.epg-time {
+    font-weight: 700;
+    color: var(--primary);
+    margin-bottom: 6px;
+    font-size: 0.9em;
+    display: flex;
+    align-items: center;
+    gap: 8px;
+}
+
+.epg-title {
+    font-size: 1em;
+    color: var(--dark);
+    margin-bottom: 6px;
+    font-weight: 600;
+}
+
+.epg-description {
+    color: #64748b;
+    font-size: 0.85em;
+    line-height: 1.4;
+    margin-top: 6px;
+    padding: 10px;
+    background: #f8fafc;
+    border-radius: 8px;
+}
+
+.epg-item.current {
+    border-left-color: var(--success);
+    background: linear-gradient(135deg, #d1fae5 0%, white 100%);
+}
+
+.epg-item.current .epg-time {
+    color: var(--success);
+}
+
+.epg-item.past {
+    opacity: 0.7;
+}
+
+.epg-actions {
+    margin-top: 10px;
+    display: flex;
+    gap: 8px;
+}
+
+.epg-actions .btn {
+    flex: 1;
+    padding: 8px 12px;
+    font-size: 0.85em;
+}
+
+.epg-video-modal {
+    display: none;
+    position: fixed;
+    top: 0;
+    left: 0;
+    width: 100%;
+    height: 100%;
+    background: rgba(30, 41, 59, 0.95);
+    z-index: 9999;
+    align-items: center;
+    justify-content: center;
+    padding: 20px;
+}
+
+.epg-video-modal.show {
+    display: flex;
+}
+
+.epg-video-container {
+    background: white;
+    border-radius: 20px;
+    max-width: 1100px;
+    width: 100%;
+    max-height: 90vh;
+    overflow: hidden;
+    box-shadow: 0 20px 60px rgba(0, 0, 0, 0.5);
+}
+
+.epg-video-header {
+    padding: 15px 25px;
+    background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+    color: white;
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+}
+
+.epg-video-header h3 {
+    font-size: 1.2em;
+    font-weight: 700;
+    margin: 0;
+}
+
+.epg-video-close {
+    background: rgba(255, 255, 255, 0.2);
+    border: none;
+    color: white;
+    font-size: 1.4em;
+    width: 35px;
+    height: 35px;
+    border-radius: 50%;
+    cursor: pointer;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+}
+
+.epg-video-close:hover {
+    background: rgba(255, 255, 255, 0.3);
+}
+
+.epg-video-body {
+    padding: 0;
+}
+
+.epg-video-wrapper {
+    position: relative;
+    background: #000;
+    aspect-ratio: 16 / 9;
+    max-height: 65vh;
+}
+
+.epg-video-wrapper video {
+    width: 100%;
+    height: 100%;
+    display: block;
+}
+
+.epg-video-info {
+    padding: 15px 25px;
+    background: #f8fafc;
+}
+
+.epg-video-info p {
+    margin: 6px 0;
+    color: var(--dark);
+    font-size: 0.9em;
+}
+
+.cache-grid {
+    display: grid;
+    grid-template-columns: repeat(auto-fit, minmax(250px, 1fr));
+    gap: 15px;
+    margin-bottom: 25px;
+}
+
+.cache-card {
+    background: white;
+    padding: 20px;
+    border-radius: 15px;
+    border-left: 4px solid var(--primary);
+    box-shadow: 0 2px 8px rgba(0, 0, 0, 0.08);
+    contain: layout style paint;
+}
+
+.cache-card h3 {
+    color: var(--dark);
+    margin-bottom: 12px;
+    font-size: 1em;
+    font-weight: 700;
+}
+
+.cache-detail {
+    display: flex;
+    justify-content: space-between;
+    padding: 8px 0;
+    border-bottom: 1px solid var(--border);
+    font-size: 0.85em;
+}
+
+.cache-detail:last-child {
+    border-bottom: none;
+}
+
+.cache-label {
+    font-weight: 600;
+    color: #64748b;
+}
+
+.cache-value {
+    font-family: 'Courier New', monospace;
+    color: var(--dark);
+    font-weight: 600;
+}
+
+.cache-actions {
+    background: rgba(255, 255, 255, 0.95);
+    padding: 20px;
+    border-radius: 15px;
+    box-shadow: 0 2px 8px rgba(0, 0, 0, 0.1);
+}
+
+.button-group {
+    display: flex;
+    flex-wrap: wrap;
+    gap: 10px;
+}
+
+.footer {
+    background: rgba(248, 250, 252, 0.8);
+    padding: 15px;
+    text-align: center;
+    border-top: 1px solid var(--border);
+    color: #64748b;
+    font-size: 0.85em;
+}
+
+.footer a {
+    color: var(--primary);
+    text-decoration: none;
+    font-weight: 600;
+}
+
+.notification {
+    position: fixed;
+    top: 20px;
+    right: 20px;
+    padding: 12px 20px;
+    border-radius: 12px;
+    z-index: 10000;
+    color: white;
+    font-weight: 600;
+    font-size: 0.9em;
+    display: flex;
+    align-items: center;
+    gap: 10px;
+    opacity: 1;
+}
+
+.notification.notification-success {
+    background: linear-gradient(135deg, #10b981 0%, #059669 100%);
+}
+
+.notification.notification-error {
+    background: linear-gradient(135deg, #ef4444 0%, #dc2626 100%);
+}
+
+.notification.notification-info {
+    background: linear-gradient(135deg, #3b82f6 0%, #2563eb 100%);
+}
+
+.login-overlay {
+    display: flex;
+    position: fixed;
+    top: 0;
+    left: 0;
+    width: 100%;
+    height: 100%;
+    background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+    z-index: 99999;
+    align-items: center;
+    justify-content: center;
+    padding: 20px;
+}
+
+.login-overlay.hide {
+    display: none !important;
+}
+
+.login-box {
+    background: rgba(255, 255, 255, 0.95);
+    border-radius: 25px;
+    box-shadow: 0 20px 60px rgba(0, 0, 0, 0.3);
+    overflow: hidden;
+    max-width: 420px;
+    width: 100%;
+}
+
+.login-box-header {
+    background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+    color: white;
+    padding: 30px 25px;
+    text-align: center;
+}
+
+.login-box-header h1 {
+    font-size: 2em;
+    font-weight: 700;
+    margin-bottom: 8px;
+}
+
+.login-box-body {
+    padding: 30px 25px;
+}
+
+.login-form-group {
+    margin-bottom: 20px;
+}
+
+.login-form-group label {
+    display: block;
+    margin-bottom: 8px;
+    font-weight: 600;
+    color: var(--dark);
+    font-size: 0.9em;
+}
+
+.login-form-group input {
+    width: 100%;
+    padding: 12px 15px;
+    border: 2px solid var(--border);
+    border-radius: 10px;
+    font-size: 0.9em;
+}
+
+.login-form-group input:focus {
+    outline: none;
+    border-color: var(--primary);
+}
+
+.login-btn {
+    width: 100%;
+    padding: 14px;
+    background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+    color: white;
+    border: none;
+    border-radius: 10px;
+    font-size: 1em;
+    font-weight: 700;
+    cursor: pointer;
+}
+
+.login-btn:hover:not(:disabled) {
+    opacity: 0.9;
+}
+
+.login-btn:disabled {
+    opacity: 0.7;
+    cursor: not-allowed;
+}
+
+.login-error {
+    background: linear-gradient(135deg, #fee2e2 0%, #fecaca 100%);
+    color: #991b1b;
+    padding: 12px;
+    border-radius: 10px;
+    margin-bottom: 15px;
+    display: none;
+    border: 2px solid #fca5a5;
+    font-size: 0.85em;
+}
+
+.login-error.show {
+    display: block;
+}
+
+.login-info {
+    background: linear-gradient(135deg, #dbeafe 0%, #bfdbfe 100%);
+    color: #1e40af;
+    padding: 12px;
+    border-radius: 10px;
+    margin-bottom: 15px;
+    font-size: 0.85em;
+    border: 1px solid #93c5fd;
+}
+
+.password-toggle-login {
+    position: relative;
+}
+
+.password-toggle-btn-login {
+    position: absolute;
+    right: 12px;
+    top: 50%;
+    transform: translateY(-50%);
+    background: none;
+    border: none;
+    cursor: pointer;
+    color: #64748b;
+    font-size: 1.1em;
+    padding: 5px;
+}
+
+.login-type-switch {
+    text-align: center;
+    margin-top: 12px;
+    padding-top: 12px;
+    border-top: 1px solid var(--border);
+}
+
+.login-type-switch a {
+    color: var(--primary);
+    text-decoration: none;
+    font-weight: 600;
+    cursor: pointer;
+    font-size: 0.85em;
+}
+
+.loading-overlay {
+    position: fixed;
+    top: 0;
+    left: 0;
+    width: 100%;
+    height: 100%;
+    background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+    display: flex;
+    flex-direction: column;
+    align-items: center;
+    justify-content: center;
+    z-index: 99999;
+}
+
+.loading-overlay.hide {
+    display: none !important;
+}
+
+.loading-spinner-large {
+    width: 50px;
+    height: 50px;
+    border: 4px solid rgba(255,255,255,.2);
+    border-radius: 50%;
+    border-top-color: #fff;
+    animation: spin 1s linear infinite !important;
+}
+
+@keyframes spin {
+    to { transform: rotate(360deg); }
+}
+
+.loading-text {
+    color: white;
+    margin-top: 15px;
+    font-size: 1em;
+    font-weight: 600;
+}
+
+.loading-spinner {
+    text-align: center;
+    padding: 40px;
+    color: var(--primary);
+}
+
+.badge {
+    padding: 5px 12px;
+    border-radius: 15px;
+    font-size: 0.75em;
+    font-weight: 700;
+    display: inline-block;
+}
+
+.badge-success {
+    background: linear-gradient(135deg, #d1fae5 0%, #a7f3d0 100%);
+    color: #065f46;
+    border: 1px solid #6ee7b7;
+}
+
+.badge-danger {
+    background: linear-gradient(135deg, #fee2e2 0%, #fecaca 100%);
+    color: #991b1b;
+    border: 1px solid #fca5a5;
+}
+
+.empty-state {
+    text-align: center;
+    padding: 60px 30px;
+    color: #94a3b8;
+}
+
+.empty-state-icon {
+    font-size: 60px;
+    margin-bottom: 15px;
+    opacity: 0.5;
+}
+
+.empty-state-text {
+    font-size: 1em;
+    margin-bottom: 8px;
+    font-weight: 600;
+}
+
+.search-box {
+    position: relative;
+}
+
+.search-box input {
+    width: 100%;
+    padding: 12px 15px 12px 40px;
+    border: 2px solid var(--border);
+    border-radius: 12px;
+    font-size: 0.9em;
+}
+
+.search-box input:focus {
+    border-color: var(--primary);
+}
+
+.search-box::before {
+    content: '🔍';
+    position: absolute;
+    left: 12px;
+    top: 50%;
+    transform: translateY(-50%);
+    font-size: 1.1em;
+    opacity: 0.5;
+}
+
+.skeleton {
+    background: #e0e0e0;
+    border-radius: 8px;
+}
+
+.skeleton-card {
+    height: 180px;
+}
+
+@media (max-width: 768px) {
+    .app-container {
+        margin: 10px;
+        border-radius: 15px;
+    }
+
+    .app-body {
+        padding: 15px 20px;
+    }
+
+    .header {
+        padding: 15px 20px;
+    }
+
+    .header h1 {
+        font-size: 1.5em;
+    }
+
+    .header-top {
+        flex-direction: column;
+    }
+
+    .status-bar {
+        flex-direction: column;
+        gap: 10px;
+    }
+
+    .status-item {
+        width: 100%;
+        justify-content: space-between;
+    }
+
+    .tab-button {
+        min-width: 100px;
+        padding: 12px 14px;
+    }
+
+    .channel-grid {
+        grid-template-columns: 1fr;
+    }
+
+    .epg-controls {
+        grid-template-columns: 1fr;
+    }
+
+    .player-controls {
+        grid-template-columns: 1fr;
+    }
+
+    .stream-info-panel {
+        grid-template-columns: 1fr;
+    }
+
+    .cache-grid {
+        grid-template-columns: 1fr;
+    }
+
+    .button-group {
+        flex-direction: column;
+    }
+
+    .epg-video-container {
+        max-height: 95vh;
+    }
+}
+
+::-webkit-scrollbar {
+    width: 8px;
+    height: 8px;
+}
+
+::-webkit-scrollbar-track {
+    background: #f1f5f9;
+}
+
+::-webkit-scrollbar-thumb {
+    background: #cbd5e1;
+    border-radius: 4px;
+}
+
+::-webkit-scrollbar-thumb:hover {
+    background: #94a3b8;
+}
+
+.hidden {
+    display: none !important;
+}
+
+.text-center {
+    text-align: center;
+}
+
+.admin-only {
+    display: none;
+}
+
+.channel-card,
+.epg-item,
+.cache-card {
+    transform: translateZ(0);
+    backface-visibility: hidden;
+}
+
+@media print {
+    body {
+        background: white;
+    }
+
+    .header,
+    .tabs,
+    .btn,
+    .footer,
+    .notification {
+        display: none;
+    }
+}

static/index.html

@@ -0,0 +1,127 @@
+<!DOCTYPE html>
+<html lang="zh-CN">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Media Gateway</title>
+    <link rel="icon" href="data:image/svg+xml,<svg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 100 100'><defs><linearGradient id='g' x1='0%25' y1='0%25' x2='100%25' y2='100%25'><stop offset='0%25' style='stop-color:%23667eea'/><stop offset='100%25' style='stop-color:%23764ba2'/></linearGradient></defs><rect width='100' height='100' rx='20' fill='url(%23g)'/><rect x='20' y='30' width='60' height='40' rx='5' fill='white' opacity='0.3'/><rect x='25' y='35' width='50' height='30' rx='3' fill='%23fff'/><circle cx='50' cy='80' r='4' fill='%23fff'/></svg>">
+    <link rel="stylesheet" href="/static/css/style.css">
+    <link rel="preconnect" href="https://fonts.googleapis.com">
+    <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>
+</head>
+<body>
+    <div class="login-overlay" id="loginOverlay">
+        <div class="login-box">
+            <div class="login-box-header">
+                <h1>🎬 Media Gateway</h1>
+                <p id="loginSubtitle">欢迎进入</p>
+            </div>
+            <div class="login-box-body">
+                <div id="loginError" class="login-error"></div>
+                <div class="login-info">
+                    <strong>💡 登录说明</strong><br>
+                    请输入用户名和密码<br>
+                </div>
+                <form id="loginForm">
+                    <div class="login-form-group">
+                        <label for="usernameInput">👤 用户名</label>
+                        <input 
+                            type="text" 
+                            id="usernameInput" 
+                            placeholder="输入您的用户名" 
+                            autocomplete="username" 
+                            required
+                        >
+                    </div>
+                    <div class="login-form-group">
+                        <label for="passwordInput">🔒 密码</label>
+                        <div class="password-toggle-login">
+                            <input 
+                                type="password" 
+                                id="passwordInput" 
+                                placeholder="输入您的密码" 
+                                autocomplete="current-password" 
+                                required
+                            >
+                            <button type="button" class="password-toggle-btn-login" id="togglePasswordBtn">
+                                👁️
+                            </button>
+                        </div>
+                    </div>
+                    <button type="submit" class="login-btn btn-glow" id="loginBtn">
+                        🚀 立即登录
+                    </button>
+                </form>
+            </div>
+        </div>
+    </div>
+
+    <div class="app-container" id="mainContainer">
+        <header class="header">
+            <div class="header-top">
+                <div>
+                    <h1>🎬 Media Gateway</h1>
+                    <p class="subtitle">v2.0</p>
+                </div>
+                <button class="btn-logout" id="logoutBtn">
+                    🚪 退出登录
+                </button>
+            </div>
+            <div class="status-bar">
+                <div class="status-item">
+                    <span class="status-label">🟢 状态</span>
+                    <span id="apiStatus" class="status-value loading">检查中...</span>
+                </div>
+                <div class="status-item">
+                    <span class="status-label">⚡ 响应</span>
+                    <span id="responseTime" class="status-value">-</span>
+                </div>
+                <div class="status-item">
+                    <span class="status-label">👤 用户</span>
+                    <span id="currentUser" class="status-value">-</span>
+                    <span id="userTypeBadge" class="user-type-badge"></span>
+                </div>
+            </div>
+        </header>
+
+        <nav class="tabs">
+            <a href="/channels" class="tab-button" data-page="channels">
+                📋 频道列表
+            </a>
+            <a href="/player" class="tab-button" data-page="player">
+                ▶️ 直播播放
+            </a>
+            <a href="/epg" class="tab-button" data-page="epg">
+                📅 节目表
+            </a>
+            <a href="/cache" class="tab-button admin-only" data-page="cache">
+                🗄️ 缓存管理
+            </a>
+            <a href="/api-test" class="tab-button admin-only" data-page="api-test">
+                🔧 API测试
+            </a>
+        </nav>
+
+        <main class="app-body" id="appBody">
+            <div id="pageContent">
+                <div class="loading-spinner">
+                    <div class="loading-spinner-large"></div>
+                    <p style="margin-top: 15px; color: var(--primary); font-weight: 600;">加载中...</p>
+                </div>
+            </div>
+        </main>
+
+        <footer class="footer">
+            <p>
+                <strong>Media Gateway v2.0</strong> 
+            </p>
+        </footer>
+    </div>
+
+    <script src="/static/js/common.js"></script>
+    <script src="/static/js/downloader.js"></script>
+    <script src="/static/js/user-data-sync.js"></script>
+    <script src="/static/js/auth.js"></script>
+    <script src="/static/js/router.js"></script>
+</body>
+</html>

static/js/auth.js

@@ -0,0 +1,339 @@
+(function() {
+    'use strict';
+
+    const API = window.location.origin;
+    let userBadges = {};
+
+    function isLoggedIn() {
+        return sessionStorage.getItem('logged_in') === 'true';
+    }
+
+    function isAdmin() {
+        return sessionStorage.getItem('is_admin') === 'true';
+    }
+
+    function saveLogin(username, isAdminUser, badge = null) {
+        sessionStorage.setItem('logged_in', 'true');
+        sessionStorage.setItem('username', username);
+        sessionStorage.setItem('is_admin', isAdminUser ? 'true' : 'false');
+        sessionStorage.setItem('user_badge', badge || '');
+        sessionStorage.setItem('login_time', Date.now().toString());
+    }
+
+    function clearLogin() {
+        sessionStorage.clear();
+    }
+
+    async function sha256(text) {
+        try {
+            const buf = new TextEncoder().encode(text);
+            const hash = await crypto.subtle.digest('SHA-256', buf);
+            const arr = Array.from(new Uint8Array(hash));
+            return arr.map(b => b.toString(16).padStart(2, '0')).join('');
+        } catch (error) {
+            throw error;
+        }
+    }
+
+    function showError(msg) {
+        const el = document.getElementById('loginError');
+        if (el) {
+            el.textContent = '❌ ' + msg;
+            el.classList.add('show');
+            setTimeout(() => el.classList.remove('show'), 5000);
+        }
+    }
+
+    function showSuccess(msg) {
+        const el = document.getElementById('loginError');
+        if (el) {
+            el.innerHTML = msg;  // ✅ 使用 innerHTML 支持 HTML
+            el.style.background = 'linear-gradient(135deg, #d1fae5 0%, #a7f3d0 100%)';
+            el.style.color = '#065f46';
+            el.style.borderColor = '#6ee7b7';
+            el.classList.add('show');
+            setTimeout(() => {
+                el.classList.remove('show');
+                el.style.background = '';
+                el.style.color = '';
+                el.style.borderColor = '';
+            }, 2000);
+        }
+    }
+
+    async function loadBadges() {
+        try {
+            const res = await fetch(`${API}/api/badges`);
+            const data = await res.json();
+            if (data.success) {
+                userBadges = data.badges;
+            }
+        } catch (e) {
+        }
+    }
+
+    function updateAdminUI() {
+        const isAdminUser = isAdmin();
+        
+        const adminElements = document.querySelectorAll('.admin-only');
+        
+        adminElements.forEach(el => {
+            if (isAdminUser) {
+                el.style.display = '';
+                el.style.visibility = 'visible';
+                el.style.opacity = '1';
+                el.classList.remove('hidden');
+                
+                if (el.classList.contains('tab-button')) {
+                    el.style.display = 'block';
+                }
+            } else {
+                el.style.display = 'none';
+                el.style.visibility = 'hidden';
+                el.style.opacity = '0';
+                el.classList.add('hidden');
+            }
+        });
+    }
+
+    function showMainPage() {
+        const login = document.getElementById('loginOverlay');
+        const main = document.getElementById('mainContainer');
+        
+        if (!login || !main) {
+            return;
+        }
+        
+        login.classList.add('hide');
+        main.style.display = 'flex';
+        
+        const username = sessionStorage.getItem('username') || '未知';
+        const isAdminUser = isAdmin();
+        const userBadge = sessionStorage.getItem('user_badge') || '';
+        
+        const userEl = document.getElementById('currentUser');
+        if (userEl) {
+            userEl.textContent = username;
+        }
+        
+        const badge = document.getElementById('userTypeBadge');
+        if (badge) {
+            badge.innerHTML = '';
+            badge.className = 'user-type-badge';
+            
+            if (isAdminUser) {
+                badge.innerHTML = '👑 管理员';
+                badge.className = 'user-type-badge admin';
+            } else if (userBadge && userBadges[userBadge]) {
+                const badgeInfo = userBadges[userBadge];
+                
+                badge.innerHTML = `
+                    <span style="margin-right: 5px;">${badgeInfo.icon}</span>
+                    <span>${badgeInfo.name}</span>
+                `;
+                badge.style.background = badgeInfo.gradient;
+                badge.style.color = badgeInfo.color;
+                badge.style.border = `2px solid ${badgeInfo.border}`;
+                badge.style.boxShadow = `0 2px 8px ${badgeInfo.glow}`;
+                badge.style.padding = '6px 14px';
+                badge.style.borderRadius = '20px';
+                badge.style.fontSize = '0.85em';
+                badge.style.fontWeight = '700';
+                badge.style.display = 'inline-flex';
+                badge.style.alignItems = 'center';
+            } else {
+                badge.innerHTML = '👤 普通用户';
+                badge.className = 'user-type-badge user';
+            }
+        }
+        
+        updateAdminUI();
+        
+        setTimeout(() => checkAPI(), 100);
+        
+        setTimeout(() => {
+            window.dispatchEvent(new Event('user-logged-in'));
+        }, 200);
+    }
+
+    function showLoginPage() {
+        const login = document.getElementById('loginOverlay');
+        const main = document.getElementById('mainContainer');
+        
+        if (login) login.classList.remove('hide');
+        if (main) main.style.display = 'none';
+    }
+
+    async function checkAPI() {
+        try {
+            const start = Date.now();
+            const res = await fetch('/health');
+            const time = Date.now() - start;
+            const data = await res.json();
+            
+            const status = document.getElementById('apiStatus');
+            const timeEl = document.getElementById('responseTime');
+            
+            if (status) {
+                if (data.status === 'running') {
+                    status.textContent = '在线';
+                    status.className = 'status-value online';
+                } else {
+                    status.textContent = '异常';
+                    status.className = 'status-value loading';
+                }
+            }
+            
+            if (timeEl) timeEl.textContent = time + 'ms';
+        } catch (e) {
+            const status = document.getElementById('apiStatus');
+            if (status) {
+                status.textContent = '离线';
+                status.className = 'status-value offline';
+            }
+        }
+    }
+
+    async function handleLogin(e) {
+        e.preventDefault();
+        
+        const user = document.getElementById('usernameInput');
+        const pass = document.getElementById('passwordInput');
+        const btn = document.getElementById('loginBtn');
+        
+        if (!user || !pass || !btn) {
+            showError('页面元素错误');
+            return;
+        }
+        
+        const username = user.value.trim();
+        const password = pass.value;
+        
+        if (!username || !password) {
+            showError('请输入用户名和密码');
+            return;
+        }
+        
+        btn.disabled = true;
+        btn.innerHTML = '<div class="loading-spinner-large" style="width: 16px; height: 16px; border-width: 3px; margin-right: 8px; display: inline-block; vertical-align: middle;"></div> 验证中...';
+        
+        try {
+            const hash = await sha256(password);
+            
+            const res = await fetch('/api/verify-password', {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({ username, password_hash: hash })
+            });
+            
+            const data = await res.json();
+            
+            if (data.success) {
+                const isAdminUser = data.user?.is_admin || false;
+                const userBadge = data.user?.badge || null;
+                
+                // ✅ 保存用户数据到 sessionStorage
+                if (data.user_data) {
+                    const userDataKey = `user_data_${username}`;
+                    sessionStorage.setItem(userDataKey, JSON.stringify(data.user_data));
+                    console.log('✅ 用户数据已保存到 sessionStorage');
+                }
+                
+                // 生成欢迎语
+                let welcomeMsg = '✅ 登录成功！';
+                
+                
+                if (isAdminUser) {
+                    welcomeMsg += '<br><div style="margin-top: 10px; display: inline-flex; align-items: center; gap: 8px; padding: 8px 16px; background: linear-gradient(135deg, #f59e0b 0%, #ef4444 100%); color: white; border-radius: 12px; font-weight: 700;">👑 欢迎管理员</div>';
+                } else if (userBadge && userBadges[userBadge]) {
+                    const badgeInfo = userBadges[userBadge];
+                    welcomeMsg += `<br><div style="margin-top: 10px; display: inline-flex; align-items: center; gap: 8px; padding: 8px 16px; background: ${badgeInfo.gradient}; color: ${badgeInfo.color}; border: 2px solid ${badgeInfo.border}; box-shadow: 0 2px 8px ${badgeInfo.glow}; border-radius: 12px; font-weight: 700;"><span>${badgeInfo.icon}</span><span>欢迎 ${badgeInfo.name}</span></div>`;
+                } else {
+                    welcomeMsg += '<br><div style="margin-top: 10px; color: #065f46; font-weight: 600;">👤 欢迎普通用户</div>';
+                }
+                
+                showSuccess(welcomeMsg);
+                
+                saveLogin(username, isAdminUser, userBadge);
+                
+                await loadBadges();
+                
+                setTimeout(() => {
+                    showMainPage();
+                }, 1500);
+                
+            } else {
+                showError('用户名或密码错误');
+                btn.disabled = false;
+                btn.textContent = '🚀 立即登录';
+                pass.value = '';
+            }
+            
+        } catch (err) {
+            showError('登录失败: ' + err.message);
+            btn.disabled = false;
+            btn.textContent = '🚀 立即登录';
+        }
+    }
+
+    function togglePassword() {
+        const input = document.getElementById('passwordInput');
+        const btn = document.getElementById('togglePasswordBtn');
+        
+        if (!input || !btn) return;
+        
+        if (input.type === 'password') {
+            input.type = 'text';
+            btn.textContent = '🙈';
+        } else {
+            input.type = 'password';
+            btn.textContent = '👁️';
+        }
+    }
+
+    function handleLogout() {
+        if (confirm('确定要退出吗？')) {
+            clearLogin();
+            location.reload();
+        }
+    }
+
+    async function init() {
+        await loadBadges();
+        
+        if (isLoggedIn()) {
+            setTimeout(() => showMainPage(), 100);
+        } else {
+            showLoginPage();
+            setTimeout(() => {
+                const user = document.getElementById('usernameInput');
+                if (user) user.focus();
+            }, 100);
+        }
+        
+        const form = document.getElementById('loginForm');
+        const toggleBtn = document.getElementById('togglePasswordBtn');
+        const logoutBtn = document.getElementById('logoutBtn');
+        
+        if (form) {
+            form.addEventListener('submit', handleLogin);
+        }
+        
+        if (toggleBtn) {
+            toggleBtn.addEventListener('click', togglePassword);
+        }
+        
+        if (logoutBtn) {
+            logoutBtn.addEventListener('click', handleLogout);
+        }
+    }
+
+    window.isAdmin = isAdmin;
+    window.updateAdminUI = updateAdminUI;
+
+    if (document.readyState === 'loading') {
+        document.addEventListener('DOMContentLoaded', init);
+    } else {
+        init();
+    }
+})();

static/js/common.js

@@ -0,0 +1,78 @@
+(function() {
+    'use strict';
+
+    window.MediaGatewayUtils = {
+        formatTime(ts) {
+            const d = new Date(ts * 1000);
+            return d.toLocaleTimeString('ja-JP', {
+                timeZone: 'Asia/Tokyo',
+                hour: '2-digit',
+                minute: '2-digit',
+                hour12: false
+            });
+        },
+
+        formatDate(ts) {
+            const d = new Date(ts * 1000);
+            return d.toLocaleDateString('ja-JP', {
+                timeZone: 'Asia/Tokyo',
+                year: 'numeric',
+                month: '2-digit',
+                day: '2-digit'
+            }).replace(/\//g, '-');
+        },
+
+        formatDuration(sec) {
+            const h = Math.floor(sec / 3600);
+            const m = Math.floor((sec % 3600) / 60);
+            return h > 0 ? `${h}小时${m}分钟` : `${m}分钟`;
+        },
+
+        formatBytes(b) {
+            if (b === 0) return '0 B';
+            const k = 1024;
+            const sizes = ['B', 'KB', 'MB', 'GB'];
+            const i = Math.floor(Math.log(b) / Math.log(k));
+            return (b / Math.pow(k, i)).toFixed(2) + ' ' + sizes[i];
+        },
+
+        getJSTDate(d) {
+            if (!d) d = new Date();
+            const jst = new Date(d.toLocaleString('en-US', { timeZone: 'Asia/Tokyo' }));
+            return jst.toISOString().split('T')[0];
+        },
+
+        showNotification(msg, type = 'info') {
+            const old = document.querySelector('.notification');
+            if (old) old.remove();
+
+            const n = document.createElement('div');
+            n.className = `notification notification-${type}`;
+            n.textContent = msg;
+            document.body.appendChild(n);
+            
+            setTimeout(() => n.remove(), 3000);
+        },
+
+        async checkAPIStatus() {
+            try {
+                const start = Date.now();
+                const res = await fetch('/health');
+                const time = Date.now() - start;
+                const data = await res.json();
+                
+                return {
+                    success: true,
+                    status: data.status,
+                    responseTime: time,
+                    data: data
+                };
+            } catch (e) {
+                return {
+                    success: false,
+                    error: e.message
+                };
+            }
+        }
+    };
+})();

static/js/downloader.js

@@ -0,0 +1,124 @@
+class HLSDownloader {
+    constructor(fragments = [], options = {}) {
+        this.fragments = fragments.map((f, i) => ({ ...f, index: i }));
+        this.thread = options.thread || 6;
+        this.onProgress = options.onProgress || (() => {});
+        this.onError = options.onError || (() => {});
+        this.onComplete = options.onComplete || (() => {});
+        this.onItemComplete = options.onItemComplete || (() => {});
+        
+        this.buffer = [];
+        this.downloaded = 0;
+        this.totalSize = 0;
+        this.isRunning = false;
+        this.isStopped = false;
+        this.controllers = [];
+        this.currentIndex = 0;
+    }
+
+    async start() {
+        if (this.isRunning) return;
+        
+        this.isRunning = true;
+        this.isStopped = false;
+        
+        const workers = [];
+        for (let i = 0; i < Math.min(this.thread, this.fragments.length); i++) {
+            workers.push(this.downloadWorker());
+        }
+        
+        await Promise.all(workers);
+        
+        if (!this.isStopped) {
+            this.onComplete(this.buffer);
+        }
+    }
+
+    async downloadWorker() {
+        while (this.currentIndex < this.fragments.length && !this.isStopped) {
+            const index = this.currentIndex++;
+            const fragment = this.fragments[index];
+            
+            try {
+                await this.downloadFragment(fragment);
+            } catch (error) {
+                this.onError(fragment, error);
+            }
+        }
+    }
+
+    async downloadFragment(fragment) {
+        const controller = new AbortController();
+        this.controllers[fragment.index] = controller;
+        
+        try {
+            const response = await fetch(fragment.url, {
+                signal: controller.signal
+            });
+            
+            if (!response.ok) {
+                throw new Error(`HTTP ${response.status}`);
+            }
+            
+            const reader = response.body.getReader();
+            const contentLength = parseInt(response.headers.get('content-length')) || 0;
+            let receivedLength = 0;
+            const chunks = [];
+            
+            while (true) {
+                const { done, value } = await reader.read();
+                
+                if (done) break;
+                
+                chunks.push(value);
+                receivedLength += value.length;
+                
+                this.onProgress({
+                    index: fragment.index,
+                    current: receivedLength,
+                    total: contentLength,
+                    percentage: contentLength ? (receivedLength / contentLength * 100).toFixed(2) : 0
+                });
+            }
+            
+            const buffer = new Uint8Array(receivedLength);
+            let position = 0;
+            for (const chunk of chunks) {
+                buffer.set(chunk, position);
+                position += chunk.length;
+            }
+            
+            this.buffer[fragment.index] = buffer.buffer;
+            this.downloaded++;
+            this.totalSize += buffer.length;
+            
+            this.onItemComplete(fragment, buffer.buffer);
+            
+        } catch (error) {
+            if (error.name !== 'AbortError') {
+                throw error;
+            }
+        }
+    }
+
+    stop() {
+        this.isStopped = true;
+        this.isRunning = false;
+        this.controllers.forEach(controller => {
+            if (controller) controller.abort();
+        });
+    }
+
+    getProgress() {
+        return {
+            downloaded: this.downloaded,
+            total: this.fragments.length,
+            percentage: (this.downloaded / this.fragments.length * 100).toFixed(2),
+            size: this.totalSize
+        };
+    }
+}
+
+if (typeof window !== 'undefined') {
+    window.HLSDownloader = HLSDownloader;
+}

static/js/router.js

@@ -0,0 +1,215 @@
+(function() {
+    'use strict';
+
+    const pages = {
+        'channels': { title: '频道列表', subtitle: '浏览所有可用的电视频道', icon: '📋' },
+        'player': { title: '直播播放', subtitle: '在线观看电视直播并支持录制', icon: '▶️' },
+        'epg': { title: 'EPG 节目表', subtitle: '查看电视节目时间表和回看内容', icon: '📅' },
+        'cache': { title: '缓存管理', subtitle: '管理系统缓存和性能优化', icon: '🗄️', adminOnly: true },
+        'api-test': { title: 'API 测试', subtitle: '测试后端 API 接口', icon: '🔧', adminOnly: true }
+    };
+
+    let currentPage = null;
+
+    function isLoggedIn() {
+        return sessionStorage.getItem('logged_in') === 'true';
+    }
+
+    function isAdmin() {
+        if (window.isAdmin && typeof window.isAdmin === 'function') {
+            return window.isAdmin();
+        }
+        return sessionStorage.getItem('is_admin') === 'true';
+    }
+
+    function updateAdminTabs() {
+        if (window.updateAdminUI && typeof window.updateAdminUI === 'function') {
+            window.updateAdminUI();
+        } else {
+            const isAdminUser = isAdmin();
+            const adminElements = document.querySelectorAll('.admin-only');
+            
+            adminElements.forEach(el => {
+                if (isAdminUser) {
+                    el.style.display = '';
+                    el.style.visibility = 'visible';
+                    el.style.opacity = '1';
+                    el.classList.remove('hidden');
+                    
+                    if (el.classList.contains('tab-button')) {
+                        el.style.display = 'block';
+                    }
+                } else {
+                    el.style.display = 'none';
+                    el.style.visibility = 'hidden';
+                    el.style.opacity = '0';
+                    el.classList.add('hidden');
+                }
+            });
+        }
+    }
+
+    function executeScripts(container) {
+        const scripts = container.querySelectorAll('script');
+        scripts.forEach(old => {
+            const script = document.createElement('script');
+            Array.from(old.attributes).forEach(attr => {
+                script.setAttribute(attr.name, attr.value);
+            });
+            script.textContent = old.textContent;
+            old.parentNode.replaceChild(script, old);
+        });
+    }
+
+    async function loadPage(page, addHistory = true) {
+        const config = pages[page];
+        if (!config) return;
+
+        if (config.adminOnly && !isAdmin()) {
+            if (window.MediaGatewayUtils) {
+                window.MediaGatewayUtils.showNotification('此功能仅限管理员使用', 'error');
+            }
+            return;
+        }
+
+        currentPage = page;
+
+        if (addHistory) {
+            history.pushState({ page }, '', '/' + page);
+        }
+
+        const icon = document.getElementById('pageIcon');
+        const title = document.getElementById('pageTitle');
+        const subtitle = document.getElementById('pageSubtitle');
+        
+        if (icon) icon.textContent = config.icon;
+        if (title) title.textContent = config.title;
+        if (subtitle) subtitle.textContent = config.subtitle;
+        
+        document.title = config.title + ' - Media Gateway';
+
+        document.querySelectorAll('.tab-button').forEach(btn => {
+            btn.classList.toggle('active', btn.dataset.page === page);
+        });
+
+        const content = document.getElementById('pageContent');
+        if (!content) return;
+        
+        content.innerHTML = '<div class="loading-spinner"><div class="loading-spinner-large"></div><p style="margin-top: 15px; color: var(--primary); font-weight: 600;">加载中...</p></div>';
+
+        try {
+            const url = `/static/templates/${page}.html`;
+            const res = await fetch(url);
+            
+            if (!res.ok) {
+                throw new Error(`HTTP ${res.status}`);
+            }
+            
+            const html = await res.text();
+            content.innerHTML = html;
+            executeScripts(content);
+
+        } catch (err) {
+            content.innerHTML = `
+                <div style="text-align: center; padding: 60px 30px; color: var(--danger);">
+                    <div style="font-size: 60px; margin-bottom: 20px;">❌</div>
+                    <h3 style="margin-bottom: 10px;">加载失败</h3>
+                    <p style="color: #64748b;">${err.message}</p>
+                    <button class="btn btn-primary" onclick="location.reload()" style="margin-top: 20px;">
+                        🔄 重新加载
+                    </button>
+                </div>
+            `;
+        }
+    }
+
+    function navigate(page) {
+        if (!isLoggedIn()) return;
+        loadPage(page, true);
+    }
+
+    function init() {
+        if (!isLoggedIn()) return;
+
+        updateAdminTabs();
+
+        document.addEventListener('click', (e) => {
+            const link = e.target.closest('a.tab-button');
+            if (link) {
+                e.preventDefault();
+                const page = link.dataset.page;
+                
+                const config = pages[page];
+                if (config && config.adminOnly && !isAdmin()) {
+                    if (window.MediaGatewayUtils) {
+                        window.MediaGatewayUtils.showNotification('此功能仅限管理员使用', 'error');
+                    }
+                    return;
+                }
+                
+                navigate(page);
+            }
+        });
+
+        window.addEventListener('popstate', (e) => {
+            if (e.state && e.state.page) {
+                loadPage(e.state.page, false);
+            }
+        });
+
+        const path = location.pathname.substring(1) || 'channels';
+        loadPage(path, false);
+    }
+
+    window.addEventListener('user-logged-in', () => {
+        setTimeout(() => {
+            init();
+            updateAdminTabs();
+        }, 100);
+    });
+
+    if (document.readyState === 'loading') {
+        document.addEventListener('DOMContentLoaded', () => {
+            if (isLoggedIn()) {
+                init();
+            }
+        });
+    } else {
+        if (isLoggedIn()) {
+            init();
+        }
+    }
+
+    // ✅ 优化后的 navigateToPlayer 函数
+    window.navigateToPlayer = function(no, autoPlay = false) {
+        console.log('🎬 navigateToPlayer 调用', { no, autoPlay });
+        
+        // ✅ 存储参数到 sessionStorage
+        sessionStorage.setItem('player_channel', no);
+        sessionStorage.setItem('player_autoplay', autoPlay ? 'true' : 'false');
+        
+        console.log('💾 参数已保存到 sessionStorage:', {
+            player_channel: no,
+            player_autoplay: autoPlay
+        });
+        
+        // 跳转到播放器页面
+        navigate('player');
+    };
+
+    window.navigateToEPG = function(id, date) {
+        navigate('epg');
+        setTimeout(() => {
+            if (window.setEPGChannel) {
+                window.setEPGChannel(id, date);
+            }
+        }, 500);
+    };
+
+    window.updateAdminTabs = updateAdminTabs;
+    window.getCurrentPage = function() {
+        return currentPage;
+    };
+    window.navigateTo = navigate;
+
+})();

static/js/user-data-sync.js

@@ -0,0 +1,218 @@
+(function() {
+    'use strict';
+    class UserDataSync {
+        constructor() {
+            this.username = null;
+            this.data = {
+                favorite_channels: [],
+                download_concurrency: 16,
+                batch_download_concurrency: 3,
+                fab_position: { bottom: 30, right: 30 },
+                playback_history: [],
+                program_reminders: []
+            };
+            this.isInitialized = false;
+            this.pendingUpdates = {};
+            this.saveTimer = null;
+        }
+
+        /**
+         * 初始化用户数据
+         */
+        init(username) {
+            if (!username) {
+                console.warn('⚠️ UserDataSync: 未提供用户名');
+                return false;
+            }
+
+            this.username = username;
+            
+            // ✅ 从 sessionStorage 加载（登录时后端已写入）
+            const userDataKey = `user_data_${username}`;
+            const savedData = sessionStorage.getItem(userDataKey);
+            
+            if (savedData) {
+                try {
+                    const parsed = JSON.parse(savedData);
+                    this.data = { ...this.data, ...parsed };
+                    console.log('✅ 用户数据已加载:', Object.keys(this.data));
+                } catch (e) {
+                    console.error('❌ 解析用户数据失败:', e);
+                }
+            }
+            
+            this.isInitialized = true;
+            return true;
+        }
+
+        /**
+         * 标记数据已修改（防抖保存）
+         */
+        markChanged(key) {
+            if (!this.isInitialized) return;
+            
+            this.pendingUpdates[key] = this.data[key];
+            
+            // 防抖：1秒后保存
+            if (this.saveTimer) {
+                clearTimeout(this.saveTimer);
+            }
+            
+            this.saveTimer = setTimeout(() => {
+                this.save();
+            }, 1000);
+        }
+
+        /**
+         * 立即保存到后端
+         */
+        async save(force = false) {
+            if (!this.isInitialized || !this.username) return false;
+            if (!force && Object.keys(this.pendingUpdates).length === 0) return true;
+
+            const updates = force ? this.data : this.pendingUpdates;
+
+            try {
+                // ✅ 保存到 sessionStorage（同步）
+                const userDataKey = `user_data_${this.username}`;
+                sessionStorage.setItem(userDataKey, JSON.stringify(this.data));
+
+                // ✅ 通过后端保存到 Redis
+                const response = await fetch('/api/user/data/sync', {
+                    method: 'POST',
+                    headers: {
+                        'Content-Type': 'application/json'
+                    },
+                    body: JSON.stringify({
+                        username: this.username,
+                        data: updates
+                    })
+                });
+
+                if (response.ok) {
+                    console.log('✅ 用户数据已同步到 Redis:', Object.keys(updates));
+                    this.pendingUpdates = {};
+                    return true;
+                } else {
+                    console.warn('⚠️ 同步失败，数据已保存到本地');
+                    return false;
+                }
+            } catch (error) {
+                console.error('❌ 同步失败:', error);
+                return false;
+            }
+        }
+
+        // ==================== 便捷方法 ====================
+
+        getFavorites() {
+            return this.data.favorite_channels || [];
+        }
+
+        setFavorites(favorites) {
+            this.data.favorite_channels = Array.isArray(favorites) ? favorites : [];
+            this.markChanged('favorite_channels');
+        }
+
+        getDownloadConcurrency() {
+            return this.data.download_concurrency || 16;
+        }
+
+        setDownloadConcurrency(concurrency) {
+            const value = parseInt(concurrency);
+            if (value >= 1 && value <= 32) {
+                this.data.download_concurrency = value;
+                this.markChanged('download_concurrency');
+            }
+        }
+
+        getBatchConcurrency() {
+            return this.data.batch_download_concurrency || 3;
+        }
+
+        setBatchConcurrency(concurrency) {
+            const value = parseInt(concurrency);
+            if (value >= 1 && value <= 10) {
+                this.data.batch_download_concurrency = value;
+                this.markChanged('batch_download_concurrency');
+            }
+        }
+
+        getFabPosition() {
+            return this.data.fab_position || { bottom: 30, right: 30 };
+        }
+
+        setFabPosition(position) {
+            if (position && typeof position === 'object') {
+                this.data.fab_position = position;
+                this.markChanged('fab_position');
+            }
+        }
+
+        getPlaybackHistory() {
+            return this.data.playback_history || [];
+        }
+
+        addPlaybackHistory(item) {
+            if (!Array.isArray(this.data.playback_history)) {
+                this.data.playback_history = [];
+            }
+            
+            // 去重
+            this.data.playback_history = this.data.playback_history.filter(
+                h => h.path !== item.path
+            );
+            
+            // 添加到开头
+            this.data.playback_history.unshift(item);
+            
+            // 最多保留 50 条
+            if (this.data.playback_history.length > 50) {
+                this.data.playback_history = this.data.playback_history.slice(0, 50);
+            }
+            
+            this.markChanged('playback_history');
+        }
+
+        getProgramReminders() {
+            return this.data.program_reminders || [];
+        }
+
+        addProgramReminder(reminder) {
+            if (!Array.isArray(this.data.program_reminders)) {
+                this.data.program_reminders = [];
+            }
+            
+            const exists = this.data.program_reminders.some(
+                r => r.title === reminder.title && r.startTime === reminder.startTime
+            );
+            
+            if (!exists) {
+                this.data.program_reminders.push(reminder);
+                this.markChanged('program_reminders');
+            }
+        }
+
+        removeProgramReminder(reminderId) {
+            if (Array.isArray(this.data.program_reminders)) {
+                this.data.program_reminders = this.data.program_reminders.filter(
+                    r => r.id !== reminderId
+                );
+                this.markChanged('program_reminders');
+            }
+        }
+    }
+
+    // 创建全局单例
+    window.userDataSync = new UserDataSync();
+
+    // 页面卸载时保存
+    window.addEventListener('beforeunload', () => {
+        if (window.userDataSync && window.userDataSync.isInitialized) {
+            window.userDataSync.save(true);
+        }
+    });
+
+    console.log('✅ UserDataSync 已加载（无需 API）');
+
+})();

static/templates/api-test.html

@@ -0,0 +1,104 @@
+<div class="api-test-page">
+    <div class="api-tester">
+        <h2 style="font-size: 1.5em; color: var(--dark); margin-bottom: 20px;">🔧 API 接口测试工具</h2>
+        <p style="color: #64748b; margin-bottom: 30px;">测试后端 API 接口的响应速度和数据返回</p>
+
+        <div class="form-group">
+            <label for="apiEndpoint">📡 选择 API 端点</label>
+            <select id="apiEndpoint" class="form-control">
+                <option value="/health">GET /health - 健康检查</option>
+                <option value="/api/list">GET /api/list - 获取频道列表</option>
+                <option value="/api/refresh?type=all">GET /api/refresh - 刷新所有缓存</option>
+                <option value="/api/refresh?type=cid">GET /api/refresh - 刷新 CID</option>
+                <option value="/api/refresh?type=auth">GET /api/refresh - 刷新认证</option>
+            </select>
+        </div>
+
+        <button id="testBtn" class="btn btn-primary" style="width: 100%; padding: 16px; font-size: 1.05em;">
+            🚀 发送请求
+        </button>
+
+        <div class="response-container" style="margin-top: 30px;">
+            <h3 style="margin-bottom: 15px; color: var(--dark); font-size: 1.2em; display: flex; align-items: center; gap: 10px;">
+                📊 响应结果
+            </h3>
+            <pre id="apiResponse" style="background: #1e293b; color: #e2e8f0; padding: 20px; border-radius: 12px; overflow-x: auto; font-family: 'Courier New', monospace; font-size: 0.9em; line-height: 1.6; max-height: 500px; box-shadow: 0 4px 15px rgba(0, 0, 0, 0.1);">⏳ 等待发送请求...
+
+💡 提示：选择一个 API 端点后点击"发送请求"按钮</pre>
+        </div>
+    </div>
+</div>
+
+<script>
+(function() {
+    'use strict';
+
+    const API = window.location.origin;
+
+    
+    const debounce = window.MediaGatewayUtils?.debounce || function(func, wait) {
+        let timeout;
+        return function(...args) {
+            clearTimeout(timeout);
+            timeout = setTimeout(() => func(...args), wait);
+        };
+    };
+
+    async function test() {
+        const sel = document.getElementById('apiEndpoint');
+        const res = document.getElementById('apiResponse');
+        const btn = document.getElementById('testBtn');
+        
+        if (!sel || !res || !btn) return;
+        
+        const endpoint = sel.value;
+        
+        btn.disabled = true;
+        btn.innerHTML = '<div class="loading-spinner-large" style="width: 20px; height: 20px; border-width: 3px; display: inline-block; margin-right: 10px;"></div>请求中...';
+        
+        res.textContent = '⏳ 正在发送请求...\n\n请稍候...';
+
+        try {
+            const token = sessionStorage.getItem('admin_token');
+            const headers = {};
+            if (token) headers['Authorization'] = `Bearer ${token}`;
+
+            const start = Date.now();
+            const response = await fetch(`${API}${endpoint}`, { headers });
+            const time = Date.now() - start;
+            const data = await response.json();
+
+            const result = {
+                success: response.ok,
+                status: response.status,
+                statusText: response.statusText,
+                responseTime: `${time}ms`,
+                headers: Object.fromEntries(response.headers.entries()),
+                data: data
+            };
+
+            res.textContent = JSON.stringify(result, null, 2);
+            
+            if (window.MediaGatewayUtils) {
+                window.MediaGatewayUtils.showNotification(`✅ 请求成功 (${time}ms)`, 'success');
+            }
+        } catch (e) {
+            res.textContent = `❌ 请求失败\n\n错误信息：\n${e.message}\n\n堆栈追踪：\n${e.stack || '无'}`;
+            
+            if (window.MediaGatewayUtils) {
+                window.MediaGatewayUtils.showNotification('❌ 请求失败', 'error');
+            }
+        } finally {
+            btn.disabled = false;
+            btn.innerHTML = '🚀 发送请求';
+        }
+    }
+
+    window.initApiTestPage = function() {
+        const btn = document.getElementById('testBtn');
+        if (btn) btn.addEventListener('click', debounce(test, 300));
+    };
+
+    setTimeout(window.initApiTestPage, 0);
+})();
+</script>

static/templates/cache.html

@@ -0,0 +1,1006 @@
+<div class="cache-page">
+    <div class="section-header">
+        <div>
+            <h2 style="font-size: 1.5em; color: var(--dark); margin: 0;">🗄️ 缓存管理面板</h2>
+            <p style="color: #64748b; margin-top: 5px;">查看和管理系统缓存状态</p>
+        </div>
+        <button id="refreshBtn" class="btn btn-primary">
+            🔄 刷新状态
+        </button>
+    </div>
+
+    <div id="cacheStats" class="cache-grid">
+        <div class="skeleton skeleton-card"></div>
+        <div class="skeleton skeleton-card"></div>
+        <div class="skeleton skeleton-card"></div>
+        <div class="skeleton skeleton-card"></div>
+        <div class="skeleton skeleton-card"></div>
+    </div>
+
+    <!-- EPG 缓存详情 -->
+    <div class="epg-cache-section" id="epgCacheSection" style="display: none;">
+        <h3 style="margin-bottom: 20px; color: var(--dark); font-size: 1.3em;">📅 EPG 缓存详情</h3>
+        <div id="epgCacheDetails" class="epg-cache-details"></div>
+    </div>
+
+    <div class="cache-actions">
+        <h3>🧹 清理缓存</h3>
+        <p style="color: #64748b; margin-bottom: 15px; font-size: 0.9em;">选择要清理的缓存类型，清理后将重新获取数据</p>
+        <div class="button-group">
+            <button class="btn btn-warning" onclick="clearCache('cid')">
+                🔑 清理 CID
+            </button>
+            <button class="btn btn-warning" onclick="clearCache('auth')">
+                🎫 清理认证
+            </button>
+            <button class="btn btn-warning" onclick="clearCache('channels')">
+                📺 清理频道
+            </button>
+            <button class="btn btn-warning" onclick="clearCache('streams')">
+                🎬 清理流
+            </button>
+            <button class="btn btn-warning" onclick="clearCache('epg')">
+                📅 清理 EPG
+            </button>
+            <button class="btn btn-danger" onclick="clearCache('all')">
+                🗑️ 清理全部
+            </button>
+        </div>
+    </div>
+</div>
+
+<!-- ✅ 节目详情弹窗 -->
+<div class="epg-detail-modal" id="epgDetailModal">
+    <div class="epg-detail-container">
+        <div class="epg-detail-header">
+            <h3 id="epgDetailTitle">📺 节目详情</h3>
+            <button class="epg-detail-close" onclick="closeEpgDetail()">✕</button>
+        </div>
+        <div class="epg-detail-body">
+            <div id="epgDetailContent" class="epg-detail-content"></div>
+        </div>
+    </div>
+</div>
+
+<style>
+/* 缓存卡片样式增强 */
+.cache-card {
+    background: white;
+    padding: 20px;
+    border-radius: 15px;
+    border-left: 4px solid var(--primary);
+    box-shadow: 0 2px 8px rgba(0, 0, 0, 0.08);
+    contain: layout style paint;
+}
+
+.cache-card h3 {
+    color: var(--dark);
+    margin-bottom: 15px;
+    font-size: 1.1em;
+    font-weight: 700;
+    display: flex;
+    align-items: center;
+    gap: 8px;
+}
+
+.cache-detail {
+    display: flex;
+    flex-direction: column;
+    padding: 10px 0;
+    border-bottom: 1px solid var(--border);
+    font-size: 0.85em;
+}
+
+.cache-detail:last-child {
+    border-bottom: none;
+}
+
+.cache-label {
+    font-weight: 600;
+    color: #64748b;
+    margin-bottom: 5px;
+    font-size: 0.9em;
+}
+
+.cache-value {
+    font-family: 'Courier New', monospace;
+    color: var(--dark);
+    font-weight: 600;
+    word-break: break-all;
+    background: #f8fafc;
+    padding: 8px 10px;
+    border-radius: 6px;
+    font-size: 0.85em;
+    line-height: 1.5;
+    border: 1px solid #e2e8f0;
+}
+
+.cache-value.clickable {
+    cursor: pointer;
+    position: relative;
+    padding-right: 35px;
+}
+
+.cache-value.clickable:hover {
+    background: #f1f5f9;
+    border-color: #cbd5e1;
+}
+
+.copy-btn {
+    position: absolute;
+    right: 8px;
+    top: 50%;
+    transform: translateY(-50%);
+    background: var(--primary);
+    color: white;
+    border: none;
+    padding: 4px 8px;
+    border-radius: 4px;
+    cursor: pointer;
+    font-size: 0.8em;
+    transition: all 0.2s;
+}
+
+.copy-btn:hover {
+    background: var(--primary-dark);
+}
+
+.copy-btn:active {
+    transform: translateY(-50%) scale(0.95);
+}
+
+.cache-value-short {
+    color: #94a3b8;
+    font-style: italic;
+}
+
+/* EPG 缓存详情样式 */
+.epg-cache-section {
+    background: white;
+    padding: 25px;
+    border-radius: 15px;
+    margin-bottom: 25px;
+    box-shadow: 0 2px 8px rgba(0, 0, 0, 0.08);
+}
+
+.epg-cache-details {
+    display: grid;
+    gap: 20px;
+}
+
+.epg-summary-box {
+    background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+    color: white;
+    padding: 20px;
+    border-radius: 12px;
+    display: grid;
+    grid-template-columns: repeat(auto-fit, minmax(150px, 1fr));
+    gap: 15px;
+}
+
+.epg-summary-item {
+    text-align: center;
+}
+
+.epg-summary-item .label {
+    font-size: 0.85em;
+    opacity: 0.9;
+    margin-bottom: 5px;
+}
+
+.epg-summary-item .value {
+    font-size: 1.8em;
+    font-weight: 700;
+}
+
+.epg-detail-grid {
+    display: grid;
+    grid-template-columns: 1fr 1fr;
+    gap: 20px;
+    margin-top: 20px;
+}
+
+.epg-detail-box {
+    background: #f8fafc;
+    padding: 15px;
+    border-radius: 10px;
+    border: 1px solid #e2e8f0;
+}
+
+.epg-detail-box h4 {
+    margin: 0 0 15px 0;
+    color: var(--dark);
+    font-size: 1em;
+    font-weight: 700;
+}
+
+.epg-list {
+    max-height: 300px;
+    overflow-y: auto;
+}
+
+.epg-list-item {
+    padding: 10px;
+    background: white;
+    border-radius: 8px;
+    margin-bottom: 8px;
+    font-size: 0.85em;
+    border: 1px solid #e2e8f0;
+    cursor: pointer;
+    transition: all 0.2s ease;
+}
+
+.epg-list-item:hover {
+    border-color: var(--primary);
+    box-shadow: 0 2px 8px rgba(99, 102, 241, 0.2);
+    transform: translateX(4px);
+}
+
+.epg-list-item .channel-id {
+    font-weight: 700;
+    color: var(--primary);
+    margin-bottom: 5px;
+}
+
+.epg-list-item .info {
+    color: #64748b;
+    display: flex;
+    justify-content: space-between;
+    flex-wrap: wrap;
+    gap: 8px;
+}
+
+/* ✅ 节目详情弹窗样式 */
+.epg-detail-modal {
+    display: none;
+    position: fixed;
+    top: 0;
+    left: 0;
+    width: 100%;
+    height: 100%;
+    background: rgba(30, 41, 59, 0.95);
+    backdrop-filter: blur(10px);
+    z-index: 9999;
+    align-items: center;
+    justify-content: center;
+    padding: 20px;
+    overflow-y: auto;
+}
+
+.epg-detail-modal.show {
+    display: flex;
+}
+
+.epg-detail-container {
+    background: white;
+    border-radius: 20px;
+    max-width: 1000px;
+    width: 100%;
+    max-height: 90vh;
+    overflow: hidden;
+    box-shadow: 0 20px 60px rgba(0, 0, 0, 0.5);
+    animation: modalSlideIn 0.3s ease;
+}
+
+@keyframes modalSlideIn {
+    from {
+        opacity: 0;
+        transform: translateY(-30px);
+    }
+    to {
+        opacity: 1;
+        transform: translateY(0);
+    }
+}
+
+.epg-detail-header {
+    padding: 20px 25px;
+    background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+    color: white;
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+}
+
+.epg-detail-header h3 {
+    margin: 0;
+    font-size: 1.4em;
+    font-weight: 700;
+}
+
+.epg-detail-close {
+    background: rgba(255, 255, 255, 0.2);
+    border: none;
+    color: white;
+    font-size: 1.5em;
+    width: 40px;
+    height: 40px;
+    border-radius: 50%;
+    cursor: pointer;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    transition: all 0.2s ease;
+}
+
+.epg-detail-close:hover {
+    background: rgba(255, 255, 255, 0.3);
+    transform: rotate(90deg);
+}
+
+.epg-detail-body {
+    padding: 25px;
+    max-height: calc(90vh - 80px);
+    overflow-y: auto;
+}
+
+.epg-detail-content {
+    display: flex;
+    flex-direction: column;
+    gap: 15px;
+}
+
+.date-section {
+    background: #f8fafc;
+    padding: 15px;
+    border-radius: 10px;
+    border-left: 4px solid var(--primary);
+}
+
+.date-section h4 {
+    margin: 0 0 15px 0;
+    color: var(--primary);
+    font-size: 1.1em;
+    font-weight: 700;
+    display: flex;
+    align-items: center;
+    gap: 8px;
+}
+
+.program-item {
+    background: white;
+    padding: 12px;
+    border-radius: 8px;
+    margin-bottom: 8px;
+    border: 1px solid #e2e8f0;
+    transition: all 0.2s ease;
+}
+
+.program-item:hover {
+    border-color: var(--primary);
+    box-shadow: 0 2px 8px rgba(99, 102, 241, 0.1);
+}
+
+.program-time {
+    font-weight: 700;
+    color: var(--primary);
+    margin-bottom: 5px;
+    font-size: 0.9em;
+}
+
+.program-title {
+    color: var(--dark);
+    font-weight: 600;
+    margin-bottom: 3px;
+}
+
+.program-desc {
+    color: #64748b;
+    font-size: 0.85em;
+    line-height: 1.4;
+}
+
+@media (max-width: 768px) {
+    .epg-detail-grid {
+        grid-template-columns: 1fr;
+    }
+    
+    .epg-summary-box {
+        grid-template-columns: 1fr;
+    }
+}
+</style>
+
+<script>
+(function() {
+    'use strict';
+
+    const API = window.location.origin;
+    
+    // ✅ 全局变量：频道映射
+    let channelMap = {};
+
+    // 防抖
+    const debounce = window.MediaGatewayUtils?.debounce || function(func, wait) {
+        let timeout;
+        return function(...args) {
+            clearTimeout(timeout);
+            timeout = setTimeout(() => func(...args), wait);
+        };
+    };
+
+    // 复制到剪贴板
+    function copyToClipboard(text, btnElement) {
+        navigator.clipboard.writeText(text).then(() => {
+            const originalText = btnElement.textContent;
+            btnElement.textContent = '✓';
+            btnElement.style.background = '#10b981';
+            
+            setTimeout(() => {
+                btnElement.textContent = originalText;
+                btnElement.style.background = '';
+            }, 1500);
+            
+            if (window.MediaGatewayUtils) {
+                window.MediaGatewayUtils.showNotification('✅ 已复制到剪贴板', 'success');
+            }
+        }).catch(err => {
+            console.error('复制失败:', err);
+            if (window.MediaGatewayUtils) {
+                window.MediaGatewayUtils.showNotification('❌ 复制失败', 'error');
+            }
+        });
+    }
+
+    // HTML 转义函数
+    function escapeHtml(text) {
+        const div = document.createElement('div');
+        div.textContent = text;
+        return div.innerHTML;
+    }
+
+    // ✅ 创建可复制的值元素（支持显示部分但复制全部）
+    function createCopyableValue(value, label, showPartial = false) {
+        if (!value) return '<span class="cache-value-short">未缓存</span>';
+        
+        const id = 'copy_' + Math.random().toString(36).substr(2, 9);
+        
+        // ✅ 如果需要部分显示
+        let displayValue = value;
+        if (showPartial && value.length > 40) {
+            displayValue = value.substring(0, 20) + '...' + value.substring(value.length - 20);
+        }
+        
+        return `
+            <div class="cache-value clickable" style="position: relative;">
+                <span id="${id}_text" data-full-value="${escapeHtml(value)}">${escapeHtml(displayValue)}</span>
+                <button class="copy-btn" onclick="window.copyCache('${id}_text')">📋 复制</button>
+            </div>
+        `;
+    }
+
+    // ✅ 全局复制函数（复制完整值）
+    window.copyCache = function(elementId) {
+        const element = document.getElementById(elementId);
+        if (element) {
+            // ✅ 优先使用 data-full-value 属性（完整值）
+            const fullValue = element.getAttribute('data-full-value');
+            const text = fullValue || element.textContent;
+            const btn = element.nextElementSibling;
+            copyToClipboard(text, btn);
+        }
+    };
+
+    // ✅ 加载频道列表
+    async function loadChannelMap() {
+        try {
+            const res = await fetch(`${API}/api/list`);
+            if (!res.ok) throw new Error(`HTTP ${res.status}`);
+            
+            const data = await res.json();
+            if (data.success) {
+                const channels = data.channels || [];
+                channelMap = {};
+                channels.forEach(ch => {
+                    channelMap[ch.id] = ch.name;
+                });
+                console.log('✅ 频道映射加载完成:', Object.keys(channelMap).length, '个频道');
+            }
+        } catch (e) {
+            console.error('❌ 加载频道列表失败:', e);
+        }
+    }
+
+    // ✅ 获取频道名称
+    function getChannelName(channelId) {
+        return channelMap[channelId] || `频道 ${channelId}`;
+    }
+
+    // ✅ 格式化时间
+    function formatTime(timestamp) {
+        const d = new Date(timestamp * 1000);
+        return d.toLocaleTimeString('ja-JP', {
+            timeZone: 'Asia/Tokyo',
+            hour: '2-digit',
+            minute: '2-digit',
+            hour12: false
+        });
+    }
+
+    // ✅ 打开节目详情弹窗
+    window.openEpgDetail = async function(channelId) {
+        console.log('📺 打开频道详情:', channelId);
+        
+        const modal = document.getElementById('epgDetailModal');
+        const title = document.getElementById('epgDetailTitle');
+        const content = document.getElementById('epgDetailContent');
+        
+        if (!modal || !content) return;
+        
+        const channelName = getChannelName(channelId);
+        if (title) title.textContent = `📺 ${channelName} - 缓存节目`;
+        
+        content.innerHTML = `
+            <div style="text-align: center; padding: 40px;">
+                <div class="loading-spinner-large"></div>
+                <p style="margin-top: 15px; color: #64748b;">加载中...</p>
+            </div>
+        `;
+        
+        modal.classList.add('show');
+        
+        try {
+            // 获取该频道的所有缓存数据
+            const res = await fetch(`${API}/health`);
+            if (!res.ok) throw new Error(`HTTP ${res.status}`);
+            
+            const data = await res.json();
+            const epgDetail = data.cache.epg_detail;
+            
+            if (!epgDetail || !epgDetail.by_channel || !epgDetail.by_channel[channelId]) {
+                content.innerHTML = `
+                    <div class="empty-state">
+                        <div class="empty-state-icon">📅</div>
+                        <div class="empty-state-text">该频道暂无缓存数据</div>
+                    </div>
+                `;
+                return;
+            }
+            
+            const channelData = epgDetail.by_channel[channelId];
+            const dates = channelData.dates.sort();            
+            const dateDetails = await Promise.all(
+                dates.map(async (date) => {
+                    try {
+                        const epgRes = await fetch(`${API}/api/epg?vid=${channelId}&date=${date}`);
+                        if (!epgRes.ok) return null;
+                        
+                        const epgData = await epgRes.json();
+                        if (!epgData.success) return null;
+                        
+                        return {
+                            date: date,
+                            programs: epgData.epg || []
+                        };
+                    } catch (e) {
+                        console.error(`获取 ${date} 数据失败:`, e);
+                        return null;
+                    }
+                })
+            );
+            
+            // 渲染节目列表
+            let html = '';
+            
+            dateDetails.filter(d => d !== null).forEach(dateData => {
+                const { date, programs } = dateData;
+                const programCount = programs.length;
+                
+                html += `
+                    <div class="date-section">
+                        <h4>
+                            📅 ${date}
+                            <span style="font-size: 0.85em; opacity: 0.8; font-weight: 600;">
+                                (${programCount} 个节目)
+                            </span>
+                        </h4>
+                `;
+                
+                if (programs.length === 0) {
+                    html += `<p style="color: #94a3b8; text-align: center; padding: 20px;">暂无节目数据</p>`;
+                } else {
+                    programs.forEach(prog => {
+                        const startTime = formatTime(prog.time);
+                        const endTime = prog.time_end ? formatTime(prog.time_end) : '未知';
+                        const title = prog.title || prog.name || '未知节目';
+                        const desc = prog.description || '';
+                        
+                        html += `
+                            <div class="program-item">
+                                <div class="program-time">⏰ ${startTime} - ${endTime}</div>
+                                <div class="program-title">${escapeHtml(title)}</div>
+                                ${desc ? `<div class="program-desc">📝 ${escapeHtml(desc)}</div>` : ''}
+                            </div>
+                        `;
+                    });
+                }
+                
+                html += `</div>`;
+            });
+            
+            if (html === '') {
+                html = `
+                    <div class="empty-state">
+                        <div class="empty-state-icon">📅</div>
+                        <div class="empty-state-text">暂无节目数据</div>
+                    </div>
+                `;
+            }
+            
+            content.innerHTML = html;
+            
+        } catch (e) {
+            console.error('加载失败:', e);
+            content.innerHTML = `
+                <div class="empty-state">
+                    <div class="empty-state-icon" style="color: var(--danger);">❌</div>
+                    <div class="empty-state-text">加载失败</div>
+                    <div class="empty-state-subtitle">${e.message}</div>
+                </div>
+            `;
+        }
+    };
+
+    // ✅ 关闭节目详情弹窗
+    window.closeEpgDetail = function() {
+        const modal = document.getElementById('epgDetailModal');
+        if (modal) modal.classList.remove('show');
+    };
+
+    // 渲染 EPG 缓存详情
+    function renderEPGDetails(epgDetail) {
+        const section = document.getElementById('epgCacheSection');
+        const details = document.getElementById('epgCacheDetails');
+        
+        if (!epgDetail || epgDetail.total_entries === 0) {
+            section.style.display = 'none';
+            return;
+        }
+        
+        section.style.display = 'block';
+        
+        let html = '';
+        
+        // 摘要信息
+        if (epgDetail.summary) {
+            html += `
+                <div class="epg-summary-box">
+                    <div class="epg-summary-item">
+                        <div class="label">📦 缓存条目</div>
+                        <div class="value">${epgDetail.total_entries}</div>
+                    </div>
+                    <div class="epg-summary-item">
+                        <div class="label">📺 频道数</div>
+                        <div class="value">${epgDetail.summary.total_channels}</div>
+                    </div>
+                    <div class="epg-summary-item">
+                        <div class="label">📅 日期数</div>
+                        <div class="value">${epgDetail.summary.total_dates}</div>
+                    </div>
+                    <div class="epg-summary-item">
+                        <div class="label">🎬 节目数</div>
+                        <div class="value">${epgDetail.summary.total_programs}</div>
+                    </div>
+                </div>
+            `;
+        }
+        
+        // 全量缓存状态
+        if (epgDetail.full_cache_available) {
+            html += `
+                <div style="background: linear-gradient(135deg, #d1fae5 0%, #a7f3d0 100%); padding: 15px; border-radius: 10px; margin-top: 20px; border: 2px solid #6ee7b7;">
+                    <div style="display: flex; align-items: center; gap: 10px; color: #065f46;">
+                        <span style="font-size: 1.5em;">✅</span>
+                        <div>
+                            <div style="font-weight: 700; margin-bottom: 5px;">全量缓存已就绪</div>
+                            <div style="font-size: 0.85em; opacity: 0.9;">
+                                缓存时间: ${epgDetail.full_cache_time} (${epgDetail.full_cache_age} 前)
+                            </div>
+                        </div>
+                    </div>
+                </div>
+            `;
+        }
+        
+        // 详细信息
+        html += '<div class="epg-detail-grid">';
+        
+        // 按频道统计
+        if (epgDetail.by_channel && Object.keys(epgDetail.by_channel).length > 0) {
+            html += `
+                <div class="epg-detail-box">
+                    <h4>📺 按频道统计 (前10个)</h4>
+                    <div class="epg-list">
+            `;
+            
+            const channels = Object.entries(epgDetail.by_channel)
+                .sort((a, b) => b[1].program_count - a[1].program_count)
+                .slice(0, 10);
+            
+            channels.forEach(([channelId, info]) => {
+                // ✅ 使用频道名称
+                const channelName = getChannelName(channelId);
+                
+                html += `
+                    <div class="epg-list-item" onclick="openEpgDetail('${channelId}')">
+                        <div class="channel-id">${channelName}</div>
+                        <div class="info">
+                            <span>📅 ${info.dates.length} 个日期</span>
+                            <span>🎬 ${info.program_count} 个节目</span>
+                        </div>
+                    </div>
+                `;
+            });
+            
+            html += `
+                    </div>
+                </div>
+            `;
+        }
+        
+        // 按日期统计
+        if (epgDetail.by_date && Object.keys(epgDetail.by_date).length > 0) {
+            html += `
+                <div class="epg-detail-box">
+                    <h4>📅 按日期统计</h4>
+                    <div class="epg-list">
+            `;
+            
+            const dates = Object.entries(epgDetail.by_date)
+                .sort((a, b) => b[0].localeCompare(a[0]));
+            
+            dates.forEach(([date, info]) => {
+                html += `
+                    <div class="epg-list-item">
+                        <div class="channel-id">${date}</div>
+                        <div class="info">
+                            <span>📺 ${info.channels.length} 个频道</span>
+                            <span>🎬 ${info.program_count} 个节目</span>
+                        </div>
+                    </div>
+                `;
+            });
+            
+            html += `
+                    </div>
+                </div>
+            `;
+        }
+        
+        html += '</div>';
+        
+        details.innerHTML = html;
+    }
+
+    async function load() {
+        const stats = document.getElementById('cacheStats');
+        if (!stats) return;
+        
+        stats.innerHTML = `
+            <div class="skeleton skeleton-card"></div>
+            <div class="skeleton skeleton-card"></div>
+            <div class="skeleton skeleton-card"></div>
+            <div class="skeleton skeleton-card"></div>
+            <div class="skeleton skeleton-card"></div>
+        `;
+
+        // ✅ 加载频道映射
+        await loadChannelMap();
+
+        try {
+            const token = sessionStorage.getItem('admin_token');
+            const headers = {};
+            if (token) headers['Authorization'] = `Bearer ${token}`;
+
+            const res = await fetch(`${API}/health`, { headers });
+            const data = await res.json();
+
+            if (!data.cache) throw new Error('无法获取缓存信息');
+
+            const cache = data.cache;
+
+            const cacheCards = [
+                {
+                    icon: '🔑',
+                    title: 'CID 缓存',
+                    color: '#6366f1',
+                    data: cache.cid
+                },
+                {
+                    icon: '🎫',
+                    title: '认证缓存',
+                    color: '#8b5cf6',
+                    data: cache.auth
+                },
+                {
+                    icon: '📺',
+                    title: '频道缓存',
+                    color: '#ec4899',
+                    data: { cached: cache.channels }
+                },
+                {
+                    icon: '🎬',
+                    title: '流缓存',
+                    color: '#f59e0b',
+                    data: { cached: cache.streams > 0, count: cache.streams }
+                },
+                {
+                    icon: '📅',
+                    title: 'EPG 缓存',
+                    color: '#10b981',
+                    data: { cached: cache.epg > 0, count: cache.epg }
+                }
+            ];
+
+            stats.innerHTML = cacheCards.map((card) => {
+                let content = '';
+
+                if (card.data.cached !== undefined) {
+                    // 状态
+                    content += `
+                        <div class="cache-detail">
+                            <span class="cache-label">状态</span>
+                            <span class="cache-value">${card.data.cached ? '✅ 已缓存' : '❌ 未缓存'}</span>
+                        </div>
+                    `;
+
+                    // CID 完整值
+                    if (card.data.cached && card.data.value) {
+                        content += `
+                            <div class="cache-detail">
+                                <span class="cache-label">完整 CID</span>
+                                ${createCopyableValue(card.data.value, 'CID', false)}
+                            </div>
+                        `;
+                    }
+
+                    // ✅ Access Token 完整值（显示部分但复制全部）
+                    if (card.data.cached && card.data.token) {
+                        content += `
+                            <div class="cache-detail">
+                                <span class="cache-label">Access Token</span>
+                                ${createCopyableValue(card.data.token, 'Token', true)}
+                            </div>
+                        `;
+                    }
+
+                    // 年龄
+                    if (card.data.age) {
+                        content += `
+                            <div class="cache-detail">
+                                <span class="cache-label">缓存时长</span>
+                                <span class="cache-value">${card.data.age}</span>
+                            </div>
+                        `;
+                    }
+
+                    // 剩余时间
+                    if (card.data.ttl) {
+                        content += `
+                            <div class="cache-detail">
+                                <span class="cache-label">剩余有效期</span>
+                                <span class="cache-value">${card.data.ttl}</span>
+                            </div>
+                        `;
+                    }
+
+                    // 存储位置
+                    if (card.data.storage) {
+                        content += `
+                            <div class="cache-detail">
+                                <span class="cache-label">存储位置</span>
+                                <span class="cache-value">${card.data.storage}</span>
+                            </div>
+                        `;
+                    }
+
+                    // 数量
+                    if (card.data.count !== undefined) {
+                        content += `
+                            <div class="cache-detail">
+                                <span class="cache-label">缓存数量</span>
+                                <span class="cache-value">${card.data.count} 个</span>
+                            </div>
+                        `;
+                    }
+                }
+
+                return `
+                    <div class="cache-card" style="border-left-color: ${card.color};">
+                        <h3>${card.icon} ${card.title}</h3>
+                        ${content}
+                    </div>
+                `;
+            }).join('');
+
+            // 渲染 EPG 缓存详情
+            if (cache.epg_detail) {
+                renderEPGDetails(cache.epg_detail);
+            }
+
+            if (window.MediaGatewayUtils) {
+                window.MediaGatewayUtils.showNotification('✅ 缓存状态已更新', 'success');
+            }
+        } catch (e) {
+            stats.innerHTML = `
+                <div style="grid-column: 1/-1; text-align: center; padding: 60px 30px; color: var(--danger);">
+                    <div style="font-size: 60px; margin-bottom: 20px;">❌</div>
+                    <h3>加载失败</h3>
+                    <p style="color: #64748b; margin-top: 10px;">${e.message}</p>
+                </div>
+            `;
+            
+            if (window.MediaGatewayUtils) {
+                window.MediaGatewayUtils.showNotification('❌ 加载失败', 'error');
+            }
+        }
+    }
+
+    window.clearCache = debounce(async function(type) {
+        const typeNames = {
+            'cid': 'CID',
+            'auth': '认证',
+            'channels': '频道',
+            'streams': '流',
+            'epg': 'EPG',
+            'all': '所有'
+        };
+
+        const msg = type === 'all' 
+            ? '⚠️ 确定要清理所有缓存吗？这将导致所有数据重新获取。' 
+            : `确定要清理 ${typeNames[type]} 缓存吗？`;
+
+        if (!confirm(msg)) return;
+
+        try {
+            const token = sessionStorage.getItem('admin_token');
+            const headers = {};
+            if (token) headers['Authorization'] = `Bearer ${token}`;
+
+            const res = await fetch(`${API}/api/refresh?type=${type}`, { headers });
+            const data = await res.json();
+
+            if (!data.success) throw new Error(data.error || '清理失败');
+
+            if (window.MediaGatewayUtils) {
+                window.MediaGatewayUtils.showNotification(`✅ ${data.message}`, 'success');
+            }
+            
+            await load();
+        } catch (e) {
+            if (window.MediaGatewayUtils) {
+                window.MediaGatewayUtils.showNotification('❌ 清理失败: ' + e.message, 'error');
+            }
+        }
+    }, 300);
+
+    window.initCachePage = function() {
+        load();
+        
+        const btn = document.getElementById('refreshBtn');
+        if (btn) btn.addEventListener('click', debounce(load, 300));
+
+        // ✅ ESC 键关闭弹窗
+        document.addEventListener('keydown', (e) => {
+            if (e.key === 'Escape') {
+                const modal = document.getElementById('epgDetailModal');
+                if (modal && modal.classList.contains('show')) {
+                    closeEpgDetail();
+                }
+            }
+        });
+
+        // ✅ 点击遮罩关闭弹窗
+        const modal = document.getElementById('epgDetailModal');
+        if (modal) {
+            modal.addEventListener('click', (e) => {
+                if (e.target === modal) {
+                    closeEpgDetail();
+                }
+            });
+        }
+    };
+
+    setTimeout(window.initCachePage, 0);
+})();
+</script>

static/templates/channels.html

@@ -0,0 +1,153 @@
+<div class="channels-page">
+    <div class="section-header">
+        <div class="search-box" style="flex: 1; max-width: 400px;">
+            <input 
+                type="text" 
+                id="channelSearch" 
+                placeholder="搜索频道..." 
+                class="form-control"
+            >
+        </div>
+        <button id="refreshChannels" class="btn btn-primary">
+            🔄 刷新
+        </button>
+    </div>
+
+    <div id="channelStats" class="stats-box">加载中...</div>
+
+    <div id="channelList" class="channel-grid"></div>
+</div>
+
+<script>
+(function() {
+    'use strict';
+
+    const API = window.location.origin;
+    let channels = [];
+    let searchTimeout;
+
+    function renderBatch(list, startIdx = 0, batchSize = 50) {
+        const el = document.getElementById('channelList');
+        if (!el) return;
+
+        if (startIdx === 0) {
+            el.innerHTML = '';
+        }
+
+        const fragment = document.createDocumentFragment();
+        const endIdx = Math.min(startIdx + batchSize, list.length);
+
+        for (let i = startIdx; i < endIdx; i++) {
+            const ch = list[i];
+            const div = document.createElement('div');
+            div.className = 'channel-card';
+            div.innerHTML = `
+                <div class="channel-name">${ch.name}</div>
+                <div class="channel-actions">
+                    <button class="btn btn-success" data-no="${ch.no}" data-action="play">▶️ 播放</button>
+                    <button class="btn btn-primary" data-id="${ch.id}" data-action="epg">📅 节目表</button>
+                </div>
+            `;
+            fragment.appendChild(div);
+        }
+
+        el.appendChild(fragment);
+
+        if (endIdx < list.length) {
+            requestAnimationFrame(() => renderBatch(list, endIdx, batchSize));
+        }
+    }
+
+    // ✅ 事件委托处理点击
+    document.addEventListener('click', (e) => {
+        const btn = e.target.closest('button[data-action]');
+        if (!btn) return;
+
+        const action = btn.dataset.action;
+
+        if (action === 'play') {
+            const no = btn.dataset.no;
+            console.log('🎬 频道列表点击播放，频道号:', no); // 调试日志
+            
+            if (window.navigateToPlayer) {
+                console.log('✅ navigateToPlayer 存在，调用并传递 autoPlay=true'); // 调试日志
+                // ✅ 修复：明确传递 autoPlay=true
+                window.navigateToPlayer(no, true);
+            } else {
+                console.error('❌ navigateToPlayer 函数不存在'); // 调试日志
+            }
+        } else if (action === 'epg') {
+            const id = btn.dataset.id;
+            const today = new Date();
+            const jst = new Date(today.toLocaleString('en-US', { timeZone: 'Asia/Tokyo' }));
+            const date = jst.toISOString().split('T')[0];
+            if (window.navigateToEPG) {
+                window.navigateToEPG(id, date);
+            }
+        }
+    });
+
+    async function load() {
+        const stats = document.getElementById('channelStats');
+        const list = document.getElementById('channelList');
+        
+        if (stats) stats.textContent = '加载中...';
+        if (list) list.innerHTML = '<div class="skeleton skeleton-card"></div>'.repeat(4);
+
+        try {
+            const res = await fetch(`${API}/api/list`);
+            if (!res.ok) throw new Error(`HTTP ${res.status}`);
+            
+            const data = await res.json();
+            if (!data.success) throw new Error(data.error || '加载失败');
+
+            channels = data.channels || [];
+
+            if (stats) {
+                const cacheIcon = data.cached ? '✅' : '🔄';
+                stats.innerHTML = `📊 共 <strong style="color: var(--primary);">${data.count || 0}</strong> 个频道 ${cacheIcon}`;
+            }
+
+            renderBatch(channels);
+            
+            if (window.MediaGatewayUtils) {
+                window.MediaGatewayUtils.showNotification(`加载 ${data.count} 个频道`, 'success');
+            }
+        } catch (e) {
+            if (list) list.innerHTML = `<div style="grid-column: 1/-1; text-align: center; padding: 40px; color: var(--danger);">❌ 加载失败: ${e.message}</div>`;
+            if (stats) stats.innerHTML = '<strong style="color: var(--danger);">❌ 加载失败</strong>';
+        }
+    }
+
+    function search(e) {
+        clearTimeout(searchTimeout);
+        searchTimeout = setTimeout(() => {
+            const q = e.target.value.toLowerCase().trim();
+            
+            if (!q) {
+                renderBatch(channels);
+                return;
+            }
+            
+            const filtered = channels.filter(ch => 
+                ch.name.toLowerCase().includes(q) ||
+                String(ch.no).includes(q)
+            );
+            
+            renderBatch(filtered);
+        }, 300);
+    }
+
+    window.initChannelsPage = function() {
+        load();
+        
+        const searchInput = document.getElementById('channelSearch');
+        const refreshBtn = document.getElementById('refreshChannels');
+        
+        if (searchInput) searchInput.addEventListener('input', search);
+        if (refreshBtn) refreshBtn.addEventListener('click', load);
+    };
+
+    setTimeout(window.initChannelsPage, 0);
+})();
+</script>

static/templates/player.html

@@ -0,0 +1,2566 @@
+<div class="mdl-player-page">
+    <div class="mdl-player-layout">
+        <div class="mdl-player-main">
+            <div class="mdl-video-wrapper">
+                <div id="dplayer"></div>
+
+                <div class="player-placeholder" id="playerPlaceholder">
+                    <div class="placeholder-icon">📺</div>
+                    <div class="placeholder-text">点击频道开始播放</div>
+                </div>
+
+                <div class="loading-indicator hidden" id="loadingIndicator">
+                    <div class="loading-spinner"></div>
+                </div>
+
+                <div class="live-badge" id="liveBadge" style="display: none;">
+                    <span class="live-dot"></span>
+                    <span class="live-text">LIVE</span>
+                </div>
+            </div>
+
+            <div class="mdl-info-panel" id="infoPanel">
+                <div class="panel-header" onclick="toggleInfoPanel()">
+                    <div class="header-left">
+                        <h3 id="currentProgramTitle">选择频道以查看节目信息</h3>
+                    </div>
+                    <button class="collapse-btn" title="折叠/展开">
+                        <span class="collapse-icon">▼</span>
+                    </button>
+                </div>
+                <div class="panel-body">
+                    <div class="time-info">
+                        <span id="programTime">--:-- ~ --:--</span>
+                        <span id="currentTime" class="current-time">--:-- (JST)</span>
+                    </div>
+                    <div class="progress-bar">
+                        <div class="progress-fill" id="programProgress"></div>
+                    </div>
+                </div>
+            </div>
+
+            <div class="mdl-record-panel" id="recordPanel">
+                <div class="record-header">
+                    <h4>🎬 录制</h4>
+                    <button id="recordBtn" class="record-btn-mini" disabled>
+                        <span class="btn-icon">⏺</span>
+                        <span class="btn-text">开始</span>
+                    </button>
+                </div>
+                <div id="recordStatus" class="record-status-mini"></div>
+            </div>
+        </div>
+
+        <button class="sidebar-expand-btn" id="expandBtn" style="display: none;" title="展开频道列表">
+            ▶ 频道
+        </button>
+
+        <div class="mdl-channel-sidebar" id="channelSidebar">
+            <div class="sidebar-header">
+                <h3>📺 频道列表</h3>
+                <button class="sidebar-collapse-btn" id="collapseBtn" title="收起侧边栏">
+                    ◀
+                </button>
+            </div>
+
+            <div class="category-tabs">
+                <button class="category-tab active" data-category="all">全部</button>
+                <button class="category-tab" data-category="favorites">⭐ 收藏</button>
+                <button class="category-tab" data-category="関東">🗼 関東</button>
+                <button class="category-tab" data-category="関西">🏯 関西</button>
+                <button class="category-tab" data-category="BS">🛰 BS</button>
+                <button class="category-tab" data-category="CS">📡 CS</button>
+            </div>
+
+            <div class="search-box">
+                <input
+                    type="text"
+                    id="channelSearch"
+                    placeholder="🔍 搜索频道..."
+                    class="search-input"
+                >
+            </div>
+
+            <div class="channel-list" id="channelList">
+                <div class="loading-state">
+                    <div class="spinner"></div>
+                    <p>加载频道中...</p>
+                </div>
+            </div>
+        </div>
+    </div>
+</div>
+
+<script src="https://cdn.jsdelivr.net/npm/hls.js@1.4.12/dist/hls.min.js"></script>
+<script src="https://cdn.jsdelivr.net/npm/dplayer@1.27.1/dist/DPlayer.min.js"></script>
+
+<link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/dplayer@1.27.1/dist/DPlayer.min.css">
+
+<script src="/static/js/user-data-sync.js"></script>
+
+<style>
+:root {
+    --gradient-main: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+    --gradient-light: linear-gradient(135deg, rgba(102, 126, 234, 0.1) 0%, rgba(118, 75, 162, 0.1) 100%);
+    --gradient-bg: linear-gradient(135deg, #f5f7fa 0%, #c3cfe2 100%);
+    --color-primary: #667eea;
+    --color-secondary: #764ba2;
+    --shadow-soft: 0 8px 32px rgba(102, 126, 234, 0.12);
+    --shadow-hover: 0 12px 48px rgba(102, 126, 234, 0.2);
+    --glass-bg: rgba(255, 255, 255, 0.25);
+    --glass-border: rgba(255, 255, 255, 0.18);
+}
+
+.mdl-player-page {
+    margin: 0;
+    padding: 0;
+    position: relative;
+    overflow: hidden;
+}
+
+.mdl-player-layout {
+    display: grid;
+    grid-template-columns: 1fr 550px;
+    gap: 0;
+    min-height: calc(100vh - 200px);
+    background: var(--gradient-bg);
+    transition: grid-template-columns 0.4s cubic-bezier(0.4, 0, 0.2, 1);
+    position: relative;
+}
+
+.mdl-player-layout.sidebar-hidden {
+    grid-template-columns: 1fr 0;
+}
+
+.mdl-player-main {
+    background: var(--glass-bg);
+    backdrop-filter: blur(20px);
+    -webkit-backdrop-filter: blur(20px);
+    border: 1px solid var(--glass-border);
+    display: flex;
+    flex-direction: column;
+    padding: 20px;
+    gap: 20px;
+}
+
+.mdl-video-wrapper {
+    position: relative;
+    width: 100%;
+    aspect-ratio: 16 / 9;
+    max-height: 65vh;
+    background: #000;
+    border-radius: 12px;
+    overflow: hidden;
+    box-shadow: 0 4px 16px rgba(0, 0, 0, 0.3),
+                0 0 0 1px rgba(102, 126, 234, 0.15);
+    transition: all 0.3s cubic-bezier(0.4, 0, 0.2, 1);
+}
+
+.mdl-video-wrapper:hover {
+    box-shadow: 0 8px 24px rgba(0, 0, 0, 0.4),
+                0 0 0 1px rgba(102, 126, 234, 0.3);
+}
+.custom-screenshot-btn {
+    position: relative;
+    top: 1px;
+}
+
+#dplayer {
+    width: 100%;
+    height: 100%;
+}
+
+#dplayer .dplayer-mask {
+    display: none !important;
+}
+
+#dplayer .dplayer-logo {
+    display: none !important;
+}
+
+#dplayer .dplayer-notice {
+    display: none !important;
+}
+
+.player-placeholder {
+    position: absolute;
+    top: 0;
+    left: 0;
+    width: 100%;
+    height: 100%;
+    background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+    display: flex;
+    flex-direction: column;
+    align-items: center;
+    justify-content: center;
+    gap: 20px;
+    z-index: 998;
+    transition: opacity 0.3s ease, visibility 0.3s ease;
+}
+
+.player-placeholder.hidden {
+    opacity: 0;
+    visibility: hidden;
+    pointer-events: none;
+}
+
+.placeholder-icon {
+    font-size: 80px;
+    animation: floatIcon 3s ease-in-out infinite;
+}
+
+@keyframes floatIcon {
+    0%, 100% { transform: translateY(0px); }
+    50% { transform: translateY(-20px); }
+}
+
+.placeholder-text {
+    color: white;
+    font-size: 24px;
+    font-weight: 700;
+    letter-spacing: 2px;
+    text-shadow: 0 2px 10px rgba(0, 0, 0, 0.3);
+}
+
+.loading-indicator {
+    position: absolute;
+    top: 0;
+    left: 0;
+    width: 100%;
+    height: 100%;
+    background: transparent;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    z-index: 100;
+    transition: opacity 0.3s ease, visibility 0.3s ease;
+    pointer-events: none;
+}
+.loading-indicator.hidden {
+    opacity: 0;
+    visibility: hidden;
+}
+
+.loading-spinner {
+    width: 60px;
+    height: 60px;
+    border: 4px solid rgba(102, 126, 234, 0.2) !important;
+    border-top: 4px solid #667eea !important;
+    border-radius: 50% !important;
+    animation: spinLoader 0.8s linear infinite !important;
+    display: block !important;
+}
+@keyframes spinLoader {
+    from { transform: rotate(0deg); }
+    to { transform: rotate(360deg); }
+}
+
+.live-badge {
+    position: absolute;
+    top: 16px;
+    left: 16px;
+    z-index: 1000;
+    display: flex;
+    align-items: center;
+    gap: 8px;
+    background: linear-gradient(135deg, rgba(239, 68, 68, 0.95) 0%, rgba(220, 38, 38, 0.95) 100%);
+    padding: 8px 16px;
+    border-radius: 20px;
+    box-shadow: 0 2px 12px rgba(239, 68, 68, 0.4);
+    backdrop-filter: blur(10px);
+    -webkit-backdrop-filter: blur(10px);
+    border: 1.5px solid rgba(255, 255, 255, 0.3);
+    font-size: 12px;
+    font-weight: 800;
+    color: white;
+    text-transform: uppercase;
+    letter-spacing: 1.5px;
+    pointer-events: none;
+    transition: opacity 0.3s ease, transform 0.3s ease;
+    animation: livePulse 2s ease-in-out infinite;
+}
+
+.live-badge.hidden {
+    opacity: 0;
+    transform: scale(0.8);
+}
+
+.live-dot {
+    width: 10px;
+    height: 10px;
+    background: white;
+    border-radius: 50%;
+    animation: liveDotBlink 1.5s ease-in-out infinite;
+    box-shadow: 0 0 8px rgba(255, 255, 255, 0.8);
+}
+
+.live-text {
+    font-size: 12px;
+    font-weight: 800;
+    text-shadow: 0 2px 4px rgba(0, 0, 0, 0.3);
+    animation: liveTextGlow 2s ease-in-out infinite;
+}
+
+@keyframes liveDotBlink {
+    0%, 100% {
+        opacity: 1;
+        transform: scale(1);
+    }
+    50% {
+        opacity: 0.3;
+        transform: scale(0.8);
+    }
+}
+
+@keyframes liveTextGlow {
+    0%, 100% {
+        text-shadow: 0 2px 4px rgba(0, 0, 0, 0.3);
+    }
+    50% {
+        text-shadow: 0 0 12px rgba(255, 255, 255, 0.8),
+                     0 2px 4px rgba(0, 0, 0, 0.3);
+    }
+}
+
+@keyframes livePulse {
+    0%, 100% {
+        transform: scale(1);
+        box-shadow: 0 2px 12px rgba(239, 68, 68, 0.4);
+    }
+    50% {
+        transform: scale(1.05);
+        box-shadow: 0 4px 20px rgba(239, 68, 68, 0.6);
+    }
+}
+
+.mdl-info-panel {
+    background: var(--glass-bg);
+    backdrop-filter: blur(24px);
+    -webkit-backdrop-filter: blur(24px);
+    border: 1px solid var(--glass-border);
+    border-radius: 20px;
+    box-shadow: var(--shadow-soft);
+    overflow: hidden;
+    transition: all 0.4s cubic-bezier(0.4, 0, 0.2, 1);
+}
+
+.mdl-info-panel:hover {
+    box-shadow: var(--shadow-hover);
+}
+
+.mdl-info-panel .panel-header {
+    padding: 20px 24px;
+    cursor: pointer;
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    user-select: none;
+    transition: all 0.3s ease;
+    border-bottom: 1px solid var(--glass-border);
+    background: linear-gradient(135deg, rgba(102, 126, 234, 0.08) 0%, rgba(118, 75, 162, 0.08) 100%);
+}
+
+.mdl-info-panel .panel-header:hover {
+    background: linear-gradient(135deg, rgba(102, 126, 234, 0.15) 0%, rgba(118, 75, 162, 0.15) 100%);
+}
+
+.header-left {
+    display: flex;
+    align-items: center;
+    gap: 16px;
+    flex: 1;
+}
+
+.header-left h3 {
+    margin: 0;
+    font-size: 19px;
+    font-weight: 700;
+    color: var(--color-primary);
+    text-shadow: 0 1px 2px rgba(0, 0, 0, 0.05);
+}
+
+.collapse-btn {
+    background: rgba(102, 126, 234, 0.12);
+    border: none;
+    color: var(--color-primary);
+    cursor: pointer;
+    padding: 10px;
+    border-radius: 10px;
+    transition: all 0.3s ease;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    backdrop-filter: blur(10px);
+}
+
+.collapse-btn:hover {
+    background: rgba(102, 126, 234, 0.25);
+    transform: scale(1.1) rotate(180deg);
+}
+
+.collapse-icon {
+    transition: transform 0.4s cubic-bezier(0.4, 0, 0.2, 1);
+    font-size: 16px;
+}
+
+.mdl-info-panel.collapsed .collapse-icon {
+    transform: rotate(-90deg);
+}
+
+.panel-body {
+    max-height: 500px;
+    overflow: hidden;
+    transition: max-height 0.4s cubic-bezier(0.4, 0, 0.2, 1),
+                padding 0.4s cubic-bezier(0.4, 0, 0.2, 1),
+                opacity 0.4s cubic-bezier(0.4, 0, 0.2, 1);
+    opacity: 1;
+    padding: 24px;
+}
+
+.mdl-info-panel.collapsed .panel-body {
+    max-height: 0;
+    padding: 0 24px;
+    opacity: 0;
+}
+
+.time-info {
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    font-size: 16px;
+    font-family: 'Courier New', monospace;
+    font-weight: 700;
+    color: var(--color-primary);
+    margin-bottom: 18px;
+    padding: 12px 16px;
+    background: linear-gradient(135deg, rgba(102, 126, 234, 0.08) 0%, rgba(118, 75, 162, 0.08) 100%);
+    border-radius: 12px;
+    border: 1px solid rgba(102, 126, 234, 0.15);
+}
+
+.current-time {
+    background: linear-gradient(135deg, rgba(102, 126, 234, 0.2) 0%, rgba(118, 75, 162, 0.2) 100%);
+    padding: 10px 18px;
+    border-radius: 14px;
+    backdrop-filter: blur(10px);
+    box-shadow: 0 3px 10px rgba(102, 126, 234, 0.15);
+    border: 1.5px solid rgba(102, 126, 234, 0.25);
+    font-weight: 800;
+}
+
+.progress-bar {
+    width: 100%;
+    height: 12px;
+    background: rgba(102, 126, 234, 0.12);
+    border-radius: 8px;
+    overflow: hidden;
+    box-shadow: inset 0 2px 6px rgba(0, 0, 0, 0.1);
+    border: 1.5px solid rgba(102, 126, 234, 0.15);
+    position: relative;
+}
+
+.progress-fill {
+    height: 100%;
+    background: linear-gradient(90deg, #667eea 0%, #764ba2 50%, #667eea 100%);
+    background-size: 200% 100%;
+    width: 0%;
+    transition: width 2s linear;
+    border-radius: 8px;
+    box-shadow: 0 0 12px rgba(102, 126, 234, 0.6),
+                inset 0 1px 0 rgba(255, 255, 255, 0.3);
+    position: relative;
+    overflow: hidden;
+    animation: progressShimmer 3s linear infinite;
+}
+
+@keyframes progressShimmer {
+    0% { background-position: 200% 0; }
+    100% { background-position: -200% 0; }
+}
+
+.progress-fill::after {
+    content: '';
+    position: absolute;
+    top: 0;
+    left: 0;
+    bottom: 0;
+    right: 0;
+    background: linear-gradient(90deg,
+        transparent,
+        rgba(255, 255, 255, 0.3),
+        transparent
+    );
+    animation: shimmer 2s infinite;
+}
+
+@keyframes shimmer {
+    0% { transform: translateX(-100%); }
+    100% { transform: translateX(100%); }
+}
+
+.mdl-record-panel {
+    background: var(--glass-bg);
+    backdrop-filter: blur(24px);
+    -webkit-backdrop-filter: blur(24px);
+    border: 1px solid var(--glass-border);
+    border-radius: 20px;
+    box-shadow: var(--shadow-soft);
+    padding: 20px;
+    transition: all 0.3s ease;
+}
+
+.mdl-record-panel:hover {
+    box-shadow: var(--shadow-hover);
+}
+
+.record-header {
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    gap: 16px;
+}
+
+.record-header h4 {
+    margin: 0;
+    font-size: 16px;
+    font-weight: 700;
+    color: var(--color-primary);
+}
+
+.record-btn-mini {
+    padding: 10px 20px;
+    background: var(--gradient-main);
+    color: white;
+    border: none;
+    border-radius: 12px;
+    cursor: pointer;
+    font-size: 14px;
+    font-weight: 600;
+    display: flex;
+    align-items: center;
+    gap: 8px;
+    transition: all 0.3s cubic-bezier(0.4, 0, 0.2, 1);
+    box-shadow: var(--shadow-soft);
+}
+
+.record-btn-mini:hover:not(:disabled) {
+    transform: translateY(-3px) scale(1.05);
+    box-shadow: var(--shadow-hover);
+}
+
+.record-btn-mini:disabled {
+    background: linear-gradient(135deg, #cbd5e0 0%, #a0aec0 100%);
+    cursor: not-allowed;
+    opacity: 0.6;
+}
+
+.record-status-mini {
+    display: none;
+    padding: 12px;
+    border-radius: 12px;
+    margin-top: 12px;
+    font-size: 13px;
+    text-align: center;
+    font-weight: 600;
+}
+
+.record-status-mini.show {
+    display: block;
+    animation: statusSlideIn 0.3s ease;
+}
+
+@keyframes statusSlideIn {
+    from { opacity: 0; transform: translateY(-10px); }
+    to { opacity: 1; transform: translateY(0); }
+}
+
+.record-status-mini.recording {
+    background: linear-gradient(135deg, rgba(251, 191, 36, 0.2) 0%, rgba(245, 158, 11, 0.2) 100%);
+    color: #f59e0b;
+    border: 1.5px solid rgba(251, 191, 36, 0.3);
+    backdrop-filter: blur(10px);
+}
+
+.record-status-mini.success {
+    background: linear-gradient(135deg, rgba(34, 197, 94, 0.2) 0%, rgba(22, 163, 74, 0.2) 100%);
+    color: #22c55e;
+    border: 1.5px solid rgba(34, 197, 94, 0.3);
+    backdrop-filter: blur(10px);
+}
+
+.record-status-mini.error {
+    background: linear-gradient(135deg, rgba(239, 68, 68, 0.2) 0%, rgba(220, 38, 38, 0.2) 100%);
+    color: #ef4444;
+    border: 1.5px solid rgba(239, 68, 68, 0.3);
+    backdrop-filter: blur(10px);
+}
+
+.sidebar-expand-btn {
+    position: fixed;
+    right: 20px;
+    top: 50%;
+    transform: translateY(-50%);
+    background: var(--gradient-main);
+    color: white;
+    border: none;
+    padding: 14px 18px;
+    border-radius: 12px 0 0 12px;
+    cursor: pointer;
+    font-size: 15px;
+    font-weight: 700;
+    box-shadow: var(--shadow-soft);
+    z-index: 1000;
+    transition: all 0.4s cubic-bezier(0.4, 0, 0.2, 1);
+    display: none;
+    backdrop-filter: blur(10px);
+}
+
+.sidebar-expand-btn:hover {
+    padding-right: 24px;
+    box-shadow: var(--shadow-hover);
+    transform: translateY(-50%) translateX(-8px);
+}
+
+.mdl-player-layout.sidebar-hidden .sidebar-expand-btn {
+    display: block;
+    animation: slideInRight 0.4s cubic-bezier(0.4, 0, 0.2, 1);
+}
+
+@keyframes slideInRight {
+    from {
+        opacity: 0;
+        transform: translateY(-50%) translateX(100%);
+    }
+    to {
+        opacity: 1;
+        transform: translateY(-50%) translateX(0);
+    }
+}
+
+.mdl-channel-sidebar {
+    background: var(--glass-bg);
+    backdrop-filter: blur(24px);
+    -webkit-backdrop-filter: blur(24px);
+    border-left: 1px solid var(--glass-border);
+    display: flex;
+    flex-direction: column;
+    max-height: calc(100vh - 200px);
+    overflow: hidden;
+    transition: transform 0.4s cubic-bezier(0.4, 0, 0.2, 1);
+    box-shadow: -8px 0 32px rgba(102, 126, 234, 0.1);
+}
+
+.mdl-player-layout.sidebar-hidden .mdl-channel-sidebar {
+    transform: translateX(100%);
+}
+
+.sidebar-header {
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    padding: 20px 24px;
+    background: linear-gradient(135deg, rgba(102, 126, 234, 0.08) 0%, rgba(118, 75, 162, 0.08) 100%);
+    border-bottom: 1px solid var(--glass-border);
+    backdrop-filter: blur(10px);
+}
+
+.sidebar-header h3 {
+    margin: 0;
+    font-size: 19px;
+    font-weight: 700;
+    color: var(--color-primary);
+}
+
+.sidebar-collapse-btn {
+    background: rgba(102, 126, 234, 0.15);
+    border: none;
+    color: var(--color-primary);
+    font-size: 20px;
+    cursor: pointer;
+    padding: 10px;
+    border-radius: 10px;
+    transition: all 0.3s ease;
+    backdrop-filter: blur(10px);
+}
+
+.sidebar-collapse-btn:hover {
+    background: rgba(102, 126, 234, 0.25);
+    transform: scale(1.15);
+}
+
+.category-tabs {
+    display: grid;
+    grid-template-columns: repeat(6, 1fr);
+    gap: 2px;
+    background: rgba(102, 126, 234, 0.1);
+    border-bottom: 1px solid var(--glass-border);
+}
+
+.category-tab {
+    background: rgba(255, 255, 255, 0.5);
+    backdrop-filter: blur(10px);
+    border: none;
+    padding: 14px 10px;
+    cursor: pointer;
+    font-size: 13px;
+    font-weight: 600;
+    transition: all 0.3s cubic-bezier(0.4, 0, 0.2, 1);
+    color: #4a5568;
+}
+
+.category-tab:hover {
+    background: var(--gradient-light);
+    transform: translateY(-2px);
+}
+
+.category-tab.active {
+    background: var(--gradient-main);
+    color: white;
+    box-shadow: 0 4px 12px rgba(102, 126, 234, 0.3);
+    transform: translateY(-2px);
+}
+
+.search-box {
+    padding: 16px;
+    background: rgba(255, 255, 255, 0.5);
+    backdrop-filter: blur(10px);
+    border-bottom: 1px solid var(--glass-border);
+}
+
+.search-input {
+    width: 100%;
+    padding: 12px 16px;
+    border: 2px solid rgba(102, 126, 234, 0.2);
+    border-radius: 12px;
+    font-size: 14px;
+    outline: none;
+    transition: all 0.3s cubic-bezier(0.4, 0, 0.2, 1);
+    background: rgba(255, 255, 255, 0.8);
+    backdrop-filter: blur(10px);
+}
+
+.search-input:focus {
+    border-color: var(--color-primary);
+    box-shadow: 0 0 0 4px rgba(102, 126, 234, 0.15);
+    transform: translateY(-2px);
+}
+
+.channel-list {
+    flex: 1;
+    overflow-y: auto;
+    background: rgba(255, 255, 255, 0.3);
+    backdrop-filter: blur(10px);
+}
+
+.loading-state {
+    padding: 80px 20px;
+    text-align: center;
+    color: #718096;
+}
+
+.spinner {
+    width: 48px;
+    height: 48px;
+    border: 4px solid rgba(102, 126, 234, 0.2);
+    border-top: 4px solid var(--color-primary);
+    border-radius: 50%;
+    animation: spin 0.8s linear infinite;
+    margin: 0 auto 20px;
+}
+
+@keyframes spin {
+    0% { transform: rotate(0deg); }
+    100% { transform: rotate(360deg); }
+}
+
+.channel-item {
+    padding: 14px 16px;
+    padding-right: 55px;
+    border-bottom: 1px solid var(--glass-border);
+    cursor: pointer;
+    transition: all 0.3s cubic-bezier(0.4, 0, 0.2, 1);
+    background: rgba(255, 255, 255, 0.5);
+    backdrop-filter: blur(10px);
+    position: relative;
+    min-height: 80px;
+}
+
+.channel-item:hover {
+    background: var(--gradient-light);
+    transform: translateX(4px);
+    box-shadow: 0 3px 10px rgba(102, 126, 234, 0.12);
+}
+
+.channel-item.active {
+    background: var(--gradient-main);
+    color: white;
+    box-shadow: 0 4px 16px rgba(102, 126, 234, 0.35);
+    transform: translateX(4px);
+}
+
+.channel-item-content {
+    display: flex;
+    align-items: flex-start;
+    gap: 12px;
+    position: relative;
+    width: 100%;
+}
+
+.favorite-btn {
+    position: absolute;
+    right: 6px;
+    top: 50%;
+    transform: translateY(-50%);
+    background: rgba(255, 255, 255, 0.95);
+    border: 1.5px solid rgba(102, 126, 234, 0.2);
+    color: #cbd5e1;
+    font-size: 16px;
+    width: 32px;
+    height: 32px;
+    border-radius: 50%;
+    cursor: pointer;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    transition: all 0.3s cubic-bezier(0.4, 0, 0.2, 1);
+    backdrop-filter: blur(10px);
+    z-index: 10;
+    opacity: 0;
+    pointer-events: none;
+}
+
+.channel-item:hover .favorite-btn {
+    opacity: 1;
+    pointer-events: auto;
+}
+
+.favorite-btn.active {
+    opacity: 1;
+    pointer-events: auto;
+    background: linear-gradient(135deg, #fbbf24 0%, #f59e0b 100%);
+    color: white;
+    border-color: #fbbf24;
+    box-shadow: 0 2px 8px rgba(251, 191, 36, 0.3);
+}
+
+.favorite-btn:hover {
+    transform: translateY(-50%) scale(1.15);
+    border-color: var(--color-primary);
+    box-shadow: 0 3px 10px rgba(102, 126, 234, 0.35);
+}
+
+.favorite-btn.active:hover {
+    transform: translateY(-50%) scale(1.15);
+    box-shadow: 0 3px 12px rgba(251, 191, 36, 0.45);
+}
+
+.channel-item.active .favorite-btn {
+    background: rgba(255, 255, 255, 0.98);
+    border-color: rgba(255, 255, 255, 0.6);
+}
+
+.channel-item.active .favorite-btn.active {
+    background: linear-gradient(135deg, #fbbf24 0%, #f59e0b 100%);
+    border-color: #fbbf24;
+}
+
+.channel-logo {
+    width: 40px;
+    height: 40px;
+    background: rgba(102, 126, 234, 0.12);
+    border-radius: 10px;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    font-size: 20px;
+    flex-shrink: 0;
+    box-shadow: 0 2px 6px rgba(102, 126, 234, 0.15);
+    transition: all 0.3s ease;
+}
+
+.channel-item:hover .channel-logo {
+    transform: scale(1.1) rotate(5deg);
+}
+
+.channel-item.active .channel-logo {
+    background: rgba(255, 255, 255, 0.3);
+    backdrop-filter: blur(10px);
+}
+
+.channel-details {
+    flex: 1;
+    min-width: 0;
+    display: flex;
+    flex-direction: column;
+    gap: 6px;
+}
+
+.program-title {
+    font-weight: 600;
+    font-size: 13px;
+    line-height: 1.4;
+    color: var(--color-primary);
+    word-wrap: break-word;
+    overflow-wrap: break-word;
+    margin: 0;
+}
+
+.channel-item.active .program-title {
+    color: white;
+    font-weight: 700;
+}
+
+.channel-meta {
+    display: flex;
+    align-items: center;
+    gap: 8px;
+    flex-wrap: wrap;
+    font-size: 11px;
+}
+
+.program-time {
+    color: #64748b;
+    font-weight: 500;
+    font-family: 'Courier New', monospace;
+    display: flex;
+    align-items: center;
+    gap: 3px;
+    white-space: nowrap;
+}
+
+.channel-item.active .program-time {
+    color: rgba(255, 255, 255, 0.85);
+}
+
+.channel-name-badge {
+    display: inline-flex;
+    align-items: center;
+    padding: 2px 10px;
+    background: rgba(102, 126, 234, 0.12);
+    color: var(--color-primary);
+    border-radius: 10px;
+    font-weight: 600;
+    font-size: 10px;
+    border: 1px solid rgba(102, 126, 234, 0.15);
+    backdrop-filter: blur(10px);
+    white-space: nowrap;
+}
+
+.channel-item.active .channel-name-badge {
+    background: rgba(255, 255, 255, 0.2);
+    color: white;
+    border-color: rgba(255, 255, 255, 0.25);
+}
+
+.channel-epg-progress {
+    width: 100%;
+    height: 4px;
+    background: rgba(102, 126, 234, 0.2);
+    border-radius: 2px;
+    overflow: hidden;
+    margin-top: 2px;
+    position: relative;
+}
+
+.channel-item.active .channel-epg-progress {
+    background: rgba(255, 255, 255, 0.3);
+}
+
+.channel-epg-progress-fill {
+    height: 100%;
+    background: var(--gradient-main);
+    width: 0%;
+    transition: width 1s linear;
+    border-radius: 2px;
+    box-shadow: 0 0 8px rgba(102, 126, 234, 0.5);
+    position: relative;
+}
+
+.channel-epg-progress-fill::after {
+    content: '';
+    position: absolute;
+    top: 0;
+    left: 0;
+    bottom: 0;
+    right: 0;
+    background: linear-gradient(90deg,
+        transparent,
+        rgba(255, 255, 255, 0.3),
+        transparent
+    );
+    animation: progressShine 2s infinite;
+}
+
+@keyframes progressShine {
+    0% { transform: translateX(-100%); }
+    100% { transform: translateX(100%); }
+}
+
+.channel-item.active .channel-epg-progress-fill {
+    background: rgba(255, 255, 255, 0.9);
+    box-shadow: 0 0 12px rgba(255, 255, 255, 0.6);
+}
+
+.channel-list::-webkit-scrollbar {
+    width: 10px;
+}
+
+.channel-list::-webkit-scrollbar-track {
+    background: rgba(102, 126, 234, 0.1);
+    border-radius: 5px;
+}
+
+.channel-list::-webkit-scrollbar-thumb {
+    background: var(--gradient-main);
+    border-radius: 5px;
+    transition: all 0.3s ease;
+}
+
+.channel-list::-webkit-scrollbar-thumb:hover {
+    background: linear-gradient(180deg, #764ba2 0%, #667eea 100%);
+}
+
+@media (max-width: 1024px) {
+    .mdl-player-layout {
+        grid-template-columns: 1fr;
+    }
+
+    .mdl-channel-sidebar {
+        max-height: 400px;
+        border-left: none;
+        border-top: 1px solid var(--glass-border);
+    }
+
+    .mdl-video-wrapper {
+        max-height: 50vh;
+        border-radius: 16px;
+    }
+
+    .sidebar-collapse-btn,
+    .sidebar-expand-btn {
+        display: none !important;
+    }
+
+    .placeholder-icon {
+        font-size: 60px;
+    }
+
+    .placeholder-text {
+        font-size: 18px;
+    }
+}
+
+@media (max-width: 768px) {
+    .category-tabs {
+        grid-template-columns: repeat(3, 1fr);
+    }
+
+    .category-tab {
+        padding: 12px 8px;
+        font-size: 12px;
+    }
+
+    .header-left h3 {
+        font-size: 17px;
+    }
+
+    .mdl-info-panel .panel-body,
+    .mdl-record-panel {
+        padding: 18px;
+    }
+
+    .program-title {
+        font-size: 13px;
+    }
+
+    .channel-meta {
+        font-size: 11px;
+    }
+
+    .placeholder-icon {
+        font-size: 50px;
+    }
+
+    .placeholder-text {
+        font-size: 16px;
+    }
+}
+
+@media (max-width: 480px) {
+    .mdl-player-layout {
+        min-height: auto;
+    }
+
+    .mdl-video-wrapper {
+        max-height: 40vh;
+        border-radius: 12px;
+    }
+
+    .mdl-channel-sidebar {
+        max-height: 50vh;
+    }
+
+    .category-tabs {
+        grid-template-columns: repeat(2, 1fr);
+    }
+
+    .header-left {
+        flex-direction: column;
+        align-items: flex-start;
+        gap: 10px;
+    }
+
+    .channel-item-content {
+        gap: 10px;
+    }
+
+    .channel-logo {
+        width: 40px;
+        height: 40px;
+        font-size: 20px;
+    }
+
+    .program-title {
+        font-size: 13px;
+    }
+
+    .channel-meta {
+        font-size: 11px;
+        gap: 6px;
+    }
+
+    .channel-name-badge {
+        padding: 2px 8px;
+        font-size: 10px;
+    }
+
+    .placeholder-icon {
+        font-size: 40px;
+    }
+
+    .placeholder-text {
+        font-size: 14px;
+    }
+
+    .loading-spinner {
+        width: 60px;
+        height: 60px;
+        border-width: 4px;
+    }
+}
+
+.hidden {
+    display: none !important;
+}
+
+.text-center {
+    text-align: center;
+}
+
+@media print {
+    .mdl-player-main {
+        background: white;
+    }
+
+    .sidebar-collapse-btn,
+    .sidebar-expand-btn,
+    .record-btn-mini,
+    .collapse-btn {
+        display: none;
+    }
+}
+
+* {
+    -webkit-font-smoothing: antialiased;
+    -moz-osx-font-smoothing: grayscale;
+}
+
+.channel-logo,
+.sidebar-collapse-btn,
+.collapse-btn,
+.record-btn-mini,
+.category-tab {
+    user-select: none;
+    -webkit-user-select: none;
+    -moz-user-select: none;
+    -ms-user-select: none;
+}
+
+.loading-state p {
+    margin-top: 10px;
+    font-size: 14px;
+    font-weight: 600;
+}
+
+.channel-list:empty::after {
+    content: '暂无频道';
+    display: block;
+    text-align: center;
+    padding: 80px 20px;
+    color: #94a3b8;
+    font-size: 16px;
+}
+</style>
+
+<script>
+(function() {
+    'use strict';
+
+    const API = window.location.origin;
+    let dp = null;
+    let currentChannel = null;
+    let currentChannelIndex = -1;
+    let channels = [];
+    let filteredChannels = [];
+    let currentCategory = 'all';
+    let cachedStreamUrls = new Map();
+    let epgUpdateInterval = null;
+    let currentEpgData = null;
+    let currentDisplayedProgram = null;
+    let sidebarEpgInterval = null;
+
+    let favoriteChannels = new Set();
+    // ✅ 添加工具函数
+    const Storage = {
+        get: (key, defaultValue = null) => {
+            try {
+                const value = localStorage.getItem(key);
+                return value ? JSON.parse(value) : defaultValue;
+            } catch (e) {
+                return defaultValue;
+            }
+        },
+        set: (key, value) => {
+            try {
+                localStorage.setItem(key, JSON.stringify(value));
+            } catch (e) {
+            }
+        },
+        remove: (key) => {
+            try {
+                localStorage.removeItem(key);
+            } catch (e) {
+            }
+        }
+    };
+    function getCurrentUsername() {
+        return sessionStorage.getItem('username') || 'guest';
+    }
+    function getUserStorageKey(key) {
+        const username = getCurrentUsername();
+        return `${username}_${key}`;
+    }
+
+    function loadFavorites() {
+        if (window.userDataSync && window.userDataSync.isInitialized) {
+            const favorites = window.userDataSync.getFavorites();
+            favoriteChannels = new Set(favorites);
+        } else {
+            const key = getUserStorageKey('favoriteChannels');
+            const saved = Storage.get(key, []);
+            favoriteChannels = new Set(saved);
+        }
+    }
+    function saveFavorites() {
+        const favorites = Array.from(favoriteChannels);
+        if (window.userDataSync && window.userDataSync.isInitialized) {
+            window.userDataSync.setFavorites(favorites);
+        } else {
+            const key = getUserStorageKey('favoriteChannels');
+            Storage.set(key, favorites);
+        }
+    }
+  
+    window.toggleFavorite = function(channelNo) {
+        if (favoriteChannels.has(channelNo)) {
+            favoriteChannels.delete(channelNo);
+        } else {
+            favoriteChannels.add(channelNo);
+        }
+        saveFavorites(); 
+        updateFavoriteButton();
+        renderChannelList();
+    };
+
+    function updateFavoriteButton() {
+        if (!currentChannel) return;
+        const allButtons = document.querySelectorAll(`.favorite-btn[data-channel-no="${currentChannel.no}"]`);
+        allButtons.forEach(btn => {
+            const isFav = favoriteChannels.has(currentChannel.no);
+            btn.classList.toggle('active', isFav);
+            btn.textContent = isFav ? '★' : '☆';
+            btn.title = isFav ? '取消收藏' : '添加收藏';
+        });
+    }
+    function getJSTNow() {
+        const now = new Date();
+        const jst = new Date(now.toLocaleString('en-US', { timeZone: 'Asia/Tokyo' }));
+        return jst;
+    }
+
+    function getJSTTimestamp() {
+        return Math.floor(getJSTNow().getTime() / 1000);
+    }
+
+    function formatJSTTime(timestamp) {
+        const d = new Date(timestamp * 1000);
+        const jstStr = d.toLocaleString('en-US', {
+            timeZone: 'Asia/Tokyo',
+            hour: '2-digit',
+            minute: '2-digit',
+            hour12: false
+        });
+        return jstStr;
+    }
+
+    function getJSTDateString(date) {
+        const d = date || new Date();
+        const jst = new Date(d.toLocaleString('en-US', { timeZone: 'Asia/Tokyo' }));
+        const year = jst.getFullYear();
+        const month = String(jst.getMonth() + 1).padStart(2, '0');
+        const day = String(jst.getDate()).padStart(2, '0');
+        return `${year}-${month}-${day}`;
+    }
+
+    function formatJSTClock() {
+        const jst = getJSTNow();
+        const hours = String(jst.getHours()).padStart(2, '0');
+        const minutes = String(jst.getMinutes()).padStart(2, '0');
+        return `${hours}:${minutes}`;
+    }
+
+    class Recorder {
+        constructor() {
+            this.active = false;
+            this.chunks = [];
+            this.durations = [];
+            this.urls = new Set();
+            this.timer = null;
+            this.abort = null;
+            this.m3u8 = '';
+            this.running = false;
+            this.startTime = 0;
+        }
+
+        async start(url, { onProgress, onError }) {
+            if (this.active) return;
+
+            this.active = this.running = true;
+            this.chunks = [];
+            this.durations = [];
+            this.urls = new Set();
+            this.m3u8 = url;
+            this.abort = new AbortController();
+            this.startTime = Date.now();
+
+            if (onProgress) {
+                this.timer = setInterval(() => {
+                    if (!this.active) return;
+                    const duration = this.durations.reduce((s, d) => s + d, 0);
+                    onProgress({
+                        segments: this.chunks.length,
+                        duration,
+                        size: this.chunks.reduce((s, c) => s + c.byteLength, 0)
+                    });
+                }, 1000);
+            }
+
+            this.loop(onError);
+        }
+
+        async loop(onError) {
+            let retries = 0;
+            let isFirstFetch = true;
+
+            while (this.running && this.active) {
+                try {
+                    const res = await fetch(this.m3u8, {
+                        signal: this.abort.signal
+                    });
+                    if (!res.ok) throw new Error(`HTTP ${res.status}`);
+
+                    const text = await res.text();
+                    const segments = this.parse(text);
+
+                    await this.download(segments, isFirstFetch);
+                    isFirstFetch = false;
+
+                    await this.sleep(2000);
+                    retries = 0;
+
+                } catch (e) {
+                    if (e.name === 'AbortError') break;
+                    if (++retries >= 3) {
+                        if (onError) onError(e);
+                        break;
+                    }
+                    await this.sleep(1000);
+                }
+            }
+        }
+
+        parse(content) {
+            const lines = content.split('\n');
+            const segments = [];
+            let duration = 0;
+
+            for (const line of lines) {
+                const l = line.trim();
+                if (l.startsWith('#EXTINF:')) {
+                    const m = l.match(/#EXTINF:([\d.]+)/);
+                    if (m) duration = parseFloat(m[1]);
+                }
+                if (l && !l.startsWith('#')) {
+                    let url = l;
+                    if (!url.startsWith('http')) {
+                        url = this.m3u8.substring(0, this.m3u8.lastIndexOf('/') + 1) + url;
+                    }
+                    segments.push({ url, duration: duration || 0 });
+                    duration = 0;
+                }
+            }
+            return segments;
+        }
+
+        async download(segments, isFirstFetch) {
+            if (isFirstFetch && segments.length > 0) {
+                const lastSegment = segments[segments.length - 1];
+                segments.length = 0;
+                segments.push(lastSegment);
+            }
+
+            for (const seg of segments) {
+                if (this.urls.has(seg.url) || !this.active) continue;
+
+                try {
+                    const res = await fetch(seg.url, { signal: this.abort.signal });
+                    if (!res.ok) throw new Error(`HTTP ${res.status}`);
+
+                    const buffer = await res.arrayBuffer();
+                    this.chunks.push(buffer);
+                    this.durations.push(seg.duration);
+                    this.urls.add(seg.url);
+                } catch (e) {
+                    if (e.name === 'AbortError') break;
+                }
+            }
+        }
+
+        async stop() {
+            this.active = this.running = false;
+            if (this.timer) clearInterval(this.timer);
+            if (this.abort) this.abort.abort();
+
+            const size = this.chunks.reduce((s, c) => s + c.byteLength, 0);
+            const duration = this.durations.reduce((s, d) => s + d, 0);
+            const blob = new Blob(this.chunks, { type: 'video/mp2t' });
+
+            return {
+                blob,
+                segments: this.chunks.length,
+                size,
+                duration: duration.toFixed(2),
+                url: URL.createObjectURL(blob)
+            };
+        }
+
+        sleep(ms) {
+            return new Promise(r => setTimeout(r, ms));
+        }
+    }
+
+    const recorder = new Recorder();
+
+    const fmt = {
+        bytes: b => b < 1024 ? b + 'B' : b < 1024*1024 ? (b/1024).toFixed(2) + 'KB' : (b/1024/1024).toFixed(2) + 'MB',
+        time: s => `${Math.floor(s/60)}:${String(Math.floor(s%60)).padStart(2,'0')}`
+    };
+
+    function getCategoryFromTags(tags) {
+        if (!tags) return 'その他';
+
+        if (tags.includes('$LIVE_CAT_関東')) return '関東';
+        if (tags.includes('$LIVE_CAT_関西')) return '関西';
+        if (tags.includes('$LIVE_CAT_BS')) return 'BS';
+        if (tags.includes('$LIVE_CAT_CS')) return 'CS';
+
+        return 'その他';
+    }
+
+    function initPlayer() {
+        if (typeof DPlayer === 'undefined') {
+            setTimeout(initPlayer, 500);
+            return false;
+        }
+
+        if (typeof Hls === 'undefined') {
+            setTimeout(initPlayer, 500);
+            return false;
+        }
+
+        initKeyboardShortcuts();
+
+        return true;
+    }
+
+    function initKeyboardShortcuts() {
+        document.addEventListener('keydown', (e) => {
+            if (e.target.tagName === 'INPUT' || e.target.tagName === 'TEXTAREA') {
+                return;
+            }
+
+            if (!dp) return;
+
+            switch(e.key.toLowerCase()) {
+                case ' ':
+                    e.preventDefault();
+                    dp.toggle();
+                    break;
+
+                case 'f':
+                    e.preventDefault();
+                    dp.fullScreen.toggle();
+                    break;
+
+                case 'm':
+                    e.preventDefault();
+                    if (dp.video) {
+                        dp.video.muted = !dp.video.muted;
+                    }
+                    break;
+
+                case 'arrowup':
+                    e.preventDefault();
+                    if (dp.video) {
+                        dp.video.volume = Math.min(1, dp.video.volume + 0.1);
+                    }
+                    break;
+
+                case 'arrowdown':
+                    e.preventDefault();
+                    if (dp.video) {
+                        dp.video.volume = Math.max(0, dp.video.volume - 0.1);
+                    }
+                    break;
+
+                case 'n':
+                    e.preventDefault();
+                    switchChannel('next');
+                    break;
+
+                case 'p':
+                    e.preventDefault();
+                    switchChannel('prev');
+                    break;
+
+                case 'c':
+                    e.preventDefault();
+                    takeCustomScreenshot();
+                    break;
+            }
+        });
+    }
+
+    function switchChannel(direction) {
+        if (filteredChannels.length === 0) {
+            return;
+        }
+
+        let newIndex = currentChannelIndex;
+
+        if (direction === 'next') {
+            newIndex = (currentChannelIndex + 1) % filteredChannels.length;
+        } else if (direction === 'prev') {
+            newIndex = (currentChannelIndex - 1 + filteredChannels.length) % filteredChannels.length;
+        }
+
+        const nextChannel = filteredChannels[newIndex];
+        if (nextChannel) {
+            playChannel(nextChannel.no);
+        }
+    }
+
+    window.toggleInfoPanel = function() {
+        const panel = document.getElementById('infoPanel');
+        if (panel) {
+            panel.classList.toggle('collapsed');
+        }
+    };
+
+    function showLoadingIndicator() {
+        const indicator = document.getElementById('loadingIndicator');
+        if (indicator) {
+            indicator.classList.remove('hidden');
+        }
+    }
+
+    function hideLoadingIndicator() {
+        const indicator = document.getElementById('loadingIndicator');
+        if (indicator) {
+            indicator.classList.add('hidden');
+        }
+    }
+
+    function hidePlaceholder() {
+        const placeholder = document.getElementById('playerPlaceholder');
+        if (placeholder) {
+            placeholder.classList.add('hidden');
+        }
+    }
+
+    function showLiveBadge() {
+        const liveBadge = document.getElementById('liveBadge');
+        if (liveBadge) {
+            liveBadge.style.display = 'flex';
+            liveBadge.classList.remove('hidden');
+        }
+    }
+
+    function hideLiveBadge() {
+        const liveBadge = document.getElementById('liveBadge');
+        if (liveBadge) {
+            liveBadge.classList.add('hidden');
+            setTimeout(() => {
+                liveBadge.style.display = 'none';
+            }, 300);
+        }
+    }
+
+    async function loadChannels() {
+        try {
+            const res = await fetch(`${API}/api/list`);
+            if (!res.ok) throw new Error(`HTTP ${res.status}`);
+
+            const data = await res.json();
+            if (!data.success) throw new Error(data.error || '加载失败');
+
+            channels = data.channels || [];
+
+            channels.forEach(ch => {
+                ch.category = getCategoryFromTags(ch.tags);
+            });
+
+            filterChannels(currentCategory);
+            renderChannelList();
+            loadAllChannelsEPG();
+
+        } catch (e) {
+            const listEl = document.getElementById('channelList');
+            if (listEl) {
+                listEl.innerHTML = '<div class="loading-state"><p style="color: #ef4444;">❌ 加载失败</p></div>';
+            }
+        }
+    }
+
+    async function loadAllChannelsEPG() {
+        const dateStr = getJSTDateString();
+        let loadedCount = 0;
+
+        const promises = channels.map(async (ch) => {
+            try {
+                const res = await fetch(`${API}/api/epg?vid=${ch.id}&date=${dateStr}`);
+                const data = await res.json();
+
+                if (data.success && data.epg && data.epg.length > 0) {
+                    ch.epgData = data.epg;
+                    loadedCount++;
+
+                    updateChannelEPGDisplay(ch.no);
+
+                    return { success: true, channel: ch.name };
+                }
+                return { success: false, channel: ch.name };
+            } catch (e) {
+                return { success: false, channel: ch.name, error: e.message };
+            }
+        });
+
+        await Promise.allSettled(promises);
+
+        startSidebarEpgUpdate();
+    }
+
+    function updateChannelEPGDisplay(channelNo) {
+        const nowSec = getJSTTimestamp();
+        const channel = channels.find(c => String(c.no) === String(channelNo));
+
+        if (!channel || !channel.epgData) return;
+
+        const currentProgram = channel.epgData.find(p =>
+            p.time <= nowSec && p.time_end > nowSec
+        );
+
+        const channelItem = document.querySelector(`.channel-item[data-channel-no="${channelNo}"]`);
+        if (!channelItem) return;
+
+        const programTitleEl = channelItem.querySelector('.program-title');
+        const programTimeEl = channelItem.querySelector('.program-time');
+        const progressEl = channelItem.querySelector('.channel-epg-progress-fill');
+
+        if (currentProgram) {
+            if (programTitleEl) {
+                programTitleEl.textContent = currentProgram.title || currentProgram.name || '正在播放';
+            }
+
+            if (programTimeEl) {
+                const startTime = formatJSTTime(currentProgram.time);
+                const endTime = currentProgram.time_end ? formatJSTTime(currentProgram.time_end) : '--:--';
+                programTimeEl.textContent = `⏰ ${startTime} ~ ${endTime}`;
+            }
+
+            if (progressEl && currentProgram.time && currentProgram.time_end) {
+                const duration = currentProgram.time_end - currentProgram.time;
+                const elapsed = nowSec - currentProgram.time;
+                const progress = Math.min(Math.max((elapsed / duration) * 100, 0), 100);
+                progressEl.style.width = `${progress.toFixed(2)}%`;
+            }
+        } else {
+            if (programTitleEl) {
+                programTitleEl.textContent = '暂无节目信息';
+            }
+            if (programTimeEl) {
+                programTimeEl.textContent = '⏰ --:-- ~ --:--';
+            }
+            if (progressEl) {
+                progressEl.style.width = '0%';
+            }
+        }
+    }
+
+    function startSidebarEpgUpdate() {
+        if (sidebarEpgInterval) {
+            clearInterval(sidebarEpgInterval);
+        }
+
+        updateAllChannelEPG();
+
+        sidebarEpgInterval = setInterval(() => {
+            updateAllChannelEPG();
+        }, 2000);
+    }
+
+    function updateAllChannelEPG() {
+        const nowSec = getJSTTimestamp();
+
+        requestAnimationFrame(() => {
+            channels.forEach(ch => {
+                if (ch.epgData && ch.epgData.length > 0) {
+                    updateChannelEPGDisplay(ch.no);
+                }
+            });
+        });
+    }
+
+    function filterChannels(category) {
+        currentCategory = category;
+
+        if (category === 'all') {
+            filteredChannels = [...channels];
+        } else if (category === 'favorites') {
+            filteredChannels = channels.filter(ch => favoriteChannels.has(ch.no));
+        } else {
+            filteredChannels = channels.filter(ch => ch.category === category);
+        }
+
+        const searchInput = document.getElementById('channelSearch');
+        if (searchInput && searchInput.value.trim()) {
+            const query = searchInput.value.toLowerCase().trim();
+            filteredChannels = filteredChannels.filter(ch =>
+                ch.name.toLowerCase().includes(query) ||
+                String(ch.no).includes(query)
+            );
+        }
+
+        renderChannelList();
+    }
+
+    function renderChannelList() {
+        const listEl = document.getElementById('channelList');
+        if (!listEl) return;
+
+        if (filteredChannels.length === 0) {
+            listEl.innerHTML = '<div class="loading-state"><p>没有频道</p></div>';
+            return;
+        }
+
+        const fragment = document.createDocumentFragment();
+        const nowSec = getJSTTimestamp();
+
+        filteredChannels.forEach((ch, index) => {
+            const div = document.createElement('div');
+            div.className = 'channel-item';
+            if (currentChannel && currentChannel.no === ch.no) {
+                div.classList.add('active');
+            }
+            div.dataset.channelNo = ch.no;
+            div.dataset.index = index;
+
+            let currentProgram = null;
+            let programText = '暂无节目信息';
+            let timeText = '--:-- ~ --:--';
+            let progress = 0;
+
+            if (ch.epgData && ch.epgData.length > 0) {
+                currentProgram = ch.epgData.find(p =>
+                    p.time <= nowSec && p.time_end > nowSec
+                );
+
+                if (currentProgram) {
+                    programText = currentProgram.title || currentProgram.name || '正在播放';
+
+                    const startTime = formatJSTTime(currentProgram.time);
+                    const endTime = currentProgram.time_end ? formatJSTTime(currentProgram.time_end) : '--:--';
+                    timeText = `${startTime} ~ ${endTime}`;
+
+                    const duration = currentProgram.time_end - currentProgram.time;
+                    const elapsed = nowSec - currentProgram.time;
+                    progress = Math.min(Math.max((elapsed / duration) * 100, 0), 100);
+                }
+            }
+
+            const isFavorite = favoriteChannels.has(ch.no);
+
+            div.innerHTML = `
+            <div class="channel-item-content">
+                <div class="channel-logo">📺</div>
+                <div class="channel-details">
+                    <div class="program-title">${programText}</div>
+                    <div class="channel-meta">
+                        <span class="program-time">⏰ ${timeText}</span>
+                        <span class="channel-name-badge">${ch.name}</span>
+                    </div>
+                    <div class="channel-epg-progress">
+                        <div class="channel-epg-progress-fill" style="width: ${progress.toFixed(2)}%"></div>
+                    </div>
+                </div>
+                <button class="favorite-btn ${isFavorite ? 'active' : ''}"
+                        data-channel-no="${ch.no}"
+                        title="${isFavorite ? '取消收藏' : '添加收藏'}">
+                    ${isFavorite ? '★' : '☆'}
+                </button>
+            </div>
+        `;
+
+            const favoriteBtn = div.querySelector('.favorite-btn');
+            if (favoriteBtn) {
+                favoriteBtn.addEventListener('click', (e) => {
+                    e.stopPropagation();
+                    toggleFavorite(ch.no);
+                });
+            }
+
+            fragment.appendChild(div);
+        });
+
+        listEl.innerHTML = '';
+        listEl.appendChild(fragment);
+
+        if (channels.length > 0 && !sidebarEpgInterval) {
+            startSidebarEpgUpdate();
+        }
+    }
+
+    async function playChannel(channelNo) {
+        const ch = channels.find(c => String(c.no) === String(channelNo));
+        if (!ch) return;
+
+        hidePlaceholder();
+        showLoadingIndicator();
+        showLiveBadge();
+
+        try {
+            let url;
+
+            if (cachedStreamUrls.has(channelNo)) {
+                url = cachedStreamUrls.get(channelNo);
+            } else {
+                const res = await fetch(`${API}/api/live/${channelNo}`);
+                const data = await res.json();
+
+                if (!data.success) {
+                    throw new Error(data.error || '获取失败');
+                }
+
+                url = data.stream.m3u8;
+                cachedStreamUrls.set(channelNo, url);
+                setTimeout(() => cachedStreamUrls.delete(channelNo), 5 * 60 * 1000);
+            }
+
+            currentChannel = ch;
+            currentChannelIndex = filteredChannels.findIndex(c => c.no === ch.no);
+
+            if (dp) {
+                try {
+                    if (dp.plugins && dp.plugins.durationInterval) {
+                        clearInterval(dp.plugins.durationInterval);
+                    }
+                    dp.destroy();
+                } catch (e) {
+                }
+                dp = null;
+            }
+
+            const container = document.getElementById('dplayer');
+            if (container) {
+                container.innerHTML = '';
+            }
+
+            let hasStartedPlaying = false;
+
+            dp = new DPlayer({
+                container: document.getElementById('dplayer'),
+                live: false,
+                autoplay: true,
+                theme: '#667eea',
+                loop: false,
+                lang: 'zh-cn',
+                screenshot: false,
+                hotkey: true,
+                preload: 'auto',
+                volume: 0.7,
+                mutex: true,
+                video: {
+                    url: url,
+                    type: 'customHls',
+                    customType: {
+                        customHls: (video, player) => {
+                            if (Hls.isSupported()) {
+                                const hls = new Hls({
+                                    enableWorker: true,
+                                    lowLatencyMode: false,
+                                    backBufferLength: 0,
+                                    maxBufferLength: 30,
+                                    maxMaxBufferLength: 60,
+                                    maxBufferSize: 60 * 1024 * 1024,
+                                    maxBufferHole: 0.5,
+                                    highBufferWatchdogPeriod: 2,
+                                    nudgeMaxRetry: 10,
+                                    liveBackBufferLength: Infinity,
+                                    liveSyncDurationCount: 3,
+                                    liveMaxLatencyDurationCount: Infinity,
+                                    liveDurationInfinity: true,
+                                    manifestLoadingTimeOut: 10000,
+                                    manifestLoadingMaxRetry: 4,
+                                    levelLoadingTimeOut: 10000,
+                                    levelLoadingMaxRetry: 4,
+                                    fragLoadingTimeOut: 20000,
+                                    fragLoadingMaxRetry: 6,
+                                    startLevel: -1,
+                                    autoStartLoad: true,
+                                    startFragPrefetch: true,
+                                    testBandwidth: true,
+                                    progressive: true,
+                                    debug: false
+                                });
+
+                                hls.loadSource(video.src);
+                                hls.attachMedia(video);
+
+                                let startTime = Date.now();
+                                let durationUpdateInterval = null;
+
+                                hls.on(Hls.Events.MANIFEST_PARSED, (event, data) => {
+                                    startTime = Date.now();
+                                    video.play().catch(err => {});
+                                });
+
+                                video.addEventListener('loadedmetadata', () => {
+                                    Object.defineProperty(video, 'duration', {
+                                        get: function() {
+                                            return Infinity;
+                                        },
+                                        configurable: true
+                                    });
+                                });
+
+                                if (!durationUpdateInterval) {
+                                    durationUpdateInterval = setInterval(() => {
+                                        try {
+                                            Object.defineProperty(video, 'duration', {
+                                                get: function() {
+                                                    return Infinity;
+                                                },
+                                                configurable: true
+                                            });
+                                        } catch (e) {}
+                                    }, 1000);
+                                }
+
+                                hls.on(Hls.Events.FRAG_LOADED, (event, data) => {
+                                    if (!hasStartedPlaying && video.readyState >= 3) {
+                                        hasStartedPlaying = true;
+                                        hideLoadingIndicator();
+                                        hideLiveBadge();
+                                    }
+                                });
+
+                                hls.on(Hls.Events.ERROR, (event, data) => {
+                                    if (data.fatal) {
+                                        if (durationUpdateInterval) {
+                                            clearInterval(durationUpdateInterval);
+                                            durationUpdateInterval = null;
+                                        }
+
+                                        hideLoadingIndicator();
+                                        hideLiveBadge();
+
+                                        switch (data.type) {
+                                            case Hls.ErrorTypes.NETWORK_ERROR:
+                                                showLoadingIndicator();
+                                                showLiveBadge();
+                                                hls.startLoad();
+                                                break;
+                                            case Hls.ErrorTypes.MEDIA_ERROR:
+                                                showLoadingIndicator();
+                                                showLiveBadge();
+                                                hls.recoverMediaError();
+                                                break;
+                                            default:
+                                                hls.destroy();
+                                                break;
+                                        }
+                                    }
+                                });
+
+                                player.plugins.hls = hls;
+                                player.plugins.durationInterval = durationUpdateInterval;
+                            } else if (video.canPlayType('application/vnd.apple.mpegurl')) {
+                                video.src = video.src;
+                            }
+                        }
+                    }
+                }
+            });
+
+            setTimeout(() => {
+                addCustomScreenshotButton();
+            }, 1000);
+
+            dp.video.addEventListener('playing', () => {
+                hasStartedPlaying = true;
+                hideLoadingIndicator();
+                hideLiveBadge();
+            });
+
+            dp.video.addEventListener('waiting', () => {
+                if (hasStartedPlaying) {
+                    showLoadingIndicator();
+                    showLiveBadge();
+                }
+            });
+
+            dp.video.addEventListener('canplay', () => {
+                if (hasStartedPlaying && dp.video.readyState >= 3) {
+                    hideLoadingIndicator();
+                    hideLiveBadge();
+                }
+            });
+
+            dp.on('play', () => {
+                const btn = document.getElementById('recordBtn');
+                if (btn) btn.disabled = false;
+            });
+
+            dp.on('pause', () => {
+            });
+
+            dp.on('error', () => {
+                hideLoadingIndicator();
+                hideLiveBadge();
+            });
+
+            updateActiveChannel();
+            loadCurrentChannelEPG();
+
+        } catch (e) {
+            hideLoadingIndicator();
+            hideLiveBadge();
+        }
+    }
+
+    function addCustomScreenshotButton() {
+        if (!dp || !dp.container) return;
+
+        const existingBtn = dp.container.querySelector('.custom-screenshot-btn');
+        if (existingBtn) return;
+
+        const controllerRight = dp.container.querySelector('.dplayer-icons.dplayer-icons-right');
+        if (!controllerRight) return;
+
+        const screenshotBtn = document.createElement('div');
+        screenshotBtn.className = 'dplayer-icon dplayer-camera-icon custom-screenshot-btn';
+        screenshotBtn.innerHTML = `
+        <span class="dplayer-icon-content">
+            <svg xmlns="http://www.w3.org/2000/svg" version="1.1" viewBox="0 0 24 24">
+                <path d="M20,5h-2.586l-1.707-1.707C15.52,3.105,15.266,3,15,3H7C6.734,3,6.48,3.105,6.293,3.293L4.586,5H2C0.895,5,0,5.895,0,7v11c0,1.105,0.895,2,2,2h18c1.105,0,2-0.895,2-2V7C22,5.895,21.105,5,20,5z M11,17c-2.761,0-5-2.239-5-5s2.239-5,5-5s5,2.239,5,5S13.761,17,11,17z M11,9c-1.657,0-3,1.343-3,3s1.343,3,3,3s3-1.343,3-3S12.657,9,11,9z"></path>
+            </svg>
+        </span>
+    `;
+        screenshotBtn.style.cursor = 'pointer';
+
+        screenshotBtn.addEventListener('click', () => {
+            takeCustomScreenshot();
+        });
+
+        const firstIcon = controllerRight.firstChild;
+        if (firstIcon) {
+            controllerRight.insertBefore(screenshotBtn, firstIcon);
+        } else {
+            controllerRight.appendChild(screenshotBtn);
+        }
+    }
+
+    function takeCustomScreenshot() {
+        if (!dp || !dp.video) return;
+
+        const video = dp.video;
+        const canvas = document.createElement('canvas');
+        canvas.width = video.videoWidth;
+        canvas.height = video.videoHeight;
+
+        const ctx = canvas.getContext('2d');
+        ctx.drawImage(video, 0, 0, canvas.width, canvas.height);
+
+        canvas.toBlob((blob) => {
+            const jst = getJSTNow();
+            const timestamp = `${jst.getFullYear()}${String(jst.getMonth()+1).padStart(2,'0')}${String(jst.getDate()).padStart(2,'0')}_${String(jst.getHours()).padStart(2,'0')}${String(jst.getMinutes()).padStart(2,'0')}${String(jst.getSeconds()).padStart(2,'0')}`;
+
+            let programName = '未知节目';
+            if (currentEpgData) {
+                const nowSec = getJSTTimestamp();
+                const currentProgram = currentEpgData.find(p => p.time <= nowSec && p.time_end > nowSec);
+                if (currentProgram && currentProgram.title) {
+                    programName = currentProgram.title;
+                }
+            }
+
+            const safeName = programName.replace(/[\\/:*?"<>|]/g, '_');
+            const channelName = currentChannel ? currentChannel.name : 'unknown';
+            const safeChannelName = channelName.replace(/[\\/:*?"<>|]/g, '_');
+
+            const filename = `${safeChannelName}_${safeName}_${timestamp}.png`;
+
+            const url = URL.createObjectURL(blob);
+            const link = document.createElement('a');
+            link.href = url;
+            link.download = filename;
+            link.style.display = 'none';
+            document.body.appendChild(link);
+            link.click();
+            document.body.removeChild(link);
+
+            setTimeout(() => URL.revokeObjectURL(url), 100);
+        }, 'image/png');
+    }
+
+    async function loadCurrentChannelEPG() {
+        if (!currentChannel) return;
+
+        const dateStr = getJSTDateString();
+
+        try {
+            const res = await fetch(`${API}/api/epg?vid=${currentChannel.id}&date=${dateStr}`);
+            const data = await res.json();
+
+            if (data.success && data.epg && data.epg.length > 0) {
+                currentChannel.epgData = data.epg;
+                currentEpgData = data.epg;
+                currentDisplayedProgram = null;
+                updateEPGDisplay();
+                startEPGUpdateInterval();
+            } else {
+                updateEPGDisplay({
+                    title: currentChannel.name,
+                    description: '暂无节目信息'
+                });
+            }
+        } catch (e) {
+            updateEPGDisplay({
+                title: currentChannel.name,
+                description: '节目信息加载失败'
+            });
+        }
+    }
+
+    function updateEPGDisplay(program) {
+        const titleEl = document.getElementById('currentProgramTitle');
+        const timeEl = document.getElementById('programTime');
+        const fillEl = document.getElementById('programProgress');
+
+        if (!program && currentEpgData) {
+            const nowSec = getJSTTimestamp();
+            program = currentEpgData.find(p => p.time <= nowSec && p.time_end > nowSec);
+        }
+
+        if (!program) {
+            if (titleEl) titleEl.textContent = currentChannel ? currentChannel.name : '选择频道以查看节目信息';
+            if (timeEl) timeEl.textContent = '--:-- ~ --:--';
+            if (fillEl) {
+                fillEl.style.transition = 'none';
+                fillEl.style.width = '0%';
+            }
+            currentDisplayedProgram = null;
+            return;
+        }
+
+        const programChanged = !currentDisplayedProgram ||
+            currentDisplayedProgram.time !== program.time ||
+            currentDisplayedProgram.time_end !== program.time_end;
+
+        if (programChanged) {
+            currentDisplayedProgram = program;
+
+            if (titleEl) titleEl.textContent = program.title || program.name || '未知节目';
+            if (timeEl) {
+                const start = formatJSTTime(program.time);
+                const end = program.time_end ? formatJSTTime(program.time_end) : '--:--';
+                timeEl.textContent = `${start} ~ ${end}`;
+            }
+
+            if (fillEl && program.time && program.time_end) {
+                const nowSec = getJSTTimestamp();
+                const duration = program.time_end - program.time;
+                const elapsed = Math.max(0, nowSec - program.time);
+                const progress = Math.min((elapsed / duration) * 100, 100);
+
+                fillEl.style.transition = 'none';
+                fillEl.style.width = `${progress.toFixed(2)}%`;
+
+                void fillEl.offsetWidth;
+
+                fillEl.style.transition = 'width 2s linear';
+            }
+        } else {
+            if (fillEl && program.time && program.time_end) {
+                const nowSec = getJSTTimestamp();
+                const duration = program.time_end - program.time;
+                const elapsed = Math.max(0, nowSec - program.time);
+                const progress = Math.min((elapsed / duration) * 100, 100);
+
+                if (fillEl.style.transition === 'none') {
+                    fillEl.style.transition = 'width 2s linear';
+                }
+
+                fillEl.style.width = `${progress.toFixed(2)}%`;
+            }
+        }
+    }
+
+    function startEPGUpdateInterval() {
+        if (epgUpdateInterval) {
+            clearInterval(epgUpdateInterval);
+            epgUpdateInterval = null;
+        }
+
+        updateEPGDisplay();
+        updateCurrentTime();
+
+        epgUpdateInterval = setInterval(() => {
+            updateEPGDisplay();
+            updateCurrentTime();
+        }, 2000);
+    }
+
+    function updateCurrentTime() {
+        const timeEl = document.getElementById('currentTime');
+        if (!timeEl) return;
+
+        timeEl.textContent = formatJSTClock() + ' (JST)';
+    }
+
+    function updateActiveChannel() {
+        document.querySelectorAll('.channel-item').forEach(item => {
+            item.classList.remove('active');
+            if (currentChannel && item.dataset.channelNo === String(currentChannel.no)) {
+                item.classList.add('active');
+                item.scrollIntoView({ behavior: 'smooth', block: 'nearest' });
+            }
+        });
+    }
+
+    function playPreviousChannel() {
+        if (filteredChannels.length === 0) return;
+
+        let newIndex = currentChannelIndex - 1;
+        if (newIndex < 0) newIndex = filteredChannels.length - 1;
+
+        const ch = filteredChannels[newIndex];
+        if (ch) playChannel(ch.no);
+    }
+
+    function playNextChannel() {
+        if (filteredChannels.length === 0) return;
+
+        let newIndex = currentChannelIndex + 1;
+        if (newIndex >= filteredChannels.length) newIndex = 0;
+
+        const ch = filteredChannels[newIndex];
+        if (ch) playChannel(ch.no);
+    }
+
+    async function toggleRecord() {
+        const btn = document.getElementById('recordBtn');
+        const status = document.getElementById('recordStatus');
+
+        if (recorder.active) {
+            btn.disabled = true;
+            btn.innerHTML = '<span class="btn-icon">⏳</span><span class="btn-text">停止中...</span>';
+            status.textContent = '⏳ 合并中...';
+            status.className = 'record-status-mini show';
+
+            const result = await recorder.stop();
+            downloadRecording(result);
+
+            btn.innerHTML = '<span class="btn-icon">⏺</span><span class="btn-text">开始</span>';
+            btn.disabled = false;
+
+            status.textContent = `✅ 完成！${result.segments}片段 | ${fmt.time(parseFloat(result.duration))} | ${fmt.bytes(result.size)}`;
+            status.className = 'record-status-mini success show';
+
+            setTimeout(() => status.className = 'record-status-mini', 10000);
+            return;
+        }
+
+        if (!currentChannel) {
+            return;
+        }
+
+        btn.innerHTML = '<span class="btn-icon">⏹</span><span class="btn-text">停止</span>';
+        status.textContent = '⏺ 准备中...';
+        status.className = 'record-status-mini recording show';
+
+        try {
+            const url = `${API}/stream/live/${currentChannel.no}.m3u8`;
+
+            await recorder.start(url, {
+                onProgress: p => {
+                    status.textContent = `⏺ ${fmt.time(p.duration)} | ${p.segments}片段 | ${fmt.bytes(p.size)}`;
+                    status.className = 'record-status-mini recording show';
+                },
+                onError: e => {
+                    btn.innerHTML = '<span class="btn-icon">⏺</span><span class="btn-text">开始</span>';
+                    btn.disabled = false;
+                    status.textContent = `❌ 失败: ${e.message}`;
+                    status.className = 'record-status-mini error show';
+                    setTimeout(() => status.className = 'record-status-mini', 5000);
+                }
+            });
+
+        } catch (e) {
+            btn.innerHTML = '<span class="btn-icon">⏺</span><span class="btn-text">开始</span>';
+            btn.disabled = false;
+            status.textContent = `❌ ${e.message}`;
+            status.className = 'record-status-mini error show';
+            setTimeout(() => status.className = 'record-status-mini', 5000);
+        }
+    }
+
+    function downloadRecording(result) {
+        const jst = getJSTNow();
+        const ts = `${jst.getFullYear()}${String(jst.getMonth()+1).padStart(2,'0')}${String(jst.getDate()).padStart(2,'0')}_${String(jst.getHours()).padStart(2,'0')}${String(jst.getMinutes()).padStart(2,'0')}`;
+
+        let name = 'live_recording';
+        if (currentChannel) {
+            const safe = currentChannel.name.replace(/[^a-zA-Z0-9\u4e00-\u9fa5]/g, '_');
+            name = `live_${ts}_${safe}`;
+        } else {
+            name = `live_${ts}`;
+        }
+
+        name += '.ts';
+
+        const a = document.createElement('a');
+        a.href = result.url;
+        a.download = name;
+        a.style.display = 'none';
+        document.body.appendChild(a);
+        a.click();
+
+        setTimeout(() => {
+            document.body.removeChild(a);
+            URL.revokeObjectURL(result.url);
+        }, 100);
+    }
+
+    function toggleSidebar() {
+        const layout = document.querySelector('.mdl-player-layout');
+        const expandBtn = document.getElementById('expandBtn');
+        const collapseBtn = document.getElementById('collapseBtn');
+
+        if (layout) {
+            const isHidden = layout.classList.toggle('sidebar-hidden');
+
+            if (expandBtn) {
+                expandBtn.style.display = isHidden ? 'block' : 'none';
+            }
+
+            if (collapseBtn) {
+                collapseBtn.textContent = isHidden ? '▶' : '◀';
+                collapseBtn.title = isHidden ? '展开频道列表' : '收起侧边栏';
+            }
+        }
+    }
+
+    function checkAutoPlay() {
+        const channelNo = sessionStorage.getItem('player_channel');
+        const autoPlay = sessionStorage.getItem('player_autoplay') === 'true';
+
+        if (channelNo) {
+            sessionStorage.removeItem('player_channel');
+            sessionStorage.removeItem('player_autoplay');
+
+            const checkInterval = setInterval(() => {
+                if (channels.length > 0) {
+                    clearInterval(checkInterval);
+
+                    if (autoPlay) {
+                        setTimeout(() => {
+                            playChannel(channelNo);
+                        }, 300);
+                    }
+                }
+            }, 100);
+
+            setTimeout(() => {
+                clearInterval(checkInterval);
+            }, 5000);
+        }
+    }
+
+    function setupEventListeners() {
+        document.querySelectorAll('.category-tab').forEach(btn => {
+            btn.addEventListener('click', () => {
+                document.querySelectorAll('.category-tab').forEach(b => b.classList.remove('active'));
+                btn.classList.add('active');
+
+                const category = btn.dataset.category;
+                filterChannels(category);
+                renderChannelList();
+            });
+        });
+
+        const searchInput = document.getElementById('channelSearch');
+        if (searchInput) {
+            let searchTimeout;
+            searchInput.addEventListener('input', () => {
+                clearTimeout(searchTimeout);
+                searchTimeout = setTimeout(() => {
+                    filterChannels(currentCategory);
+                    renderChannelList();
+                }, 300);
+            });
+        }
+
+        const channelList = document.getElementById('channelList');
+        if (channelList) {
+            channelList.addEventListener('click', (e) => {
+                const item = e.target.closest('.channel-item');
+                if (!item) return;
+
+                const channelNo = item.dataset.channelNo;
+                if (channelNo) playChannel(channelNo);
+            });
+        }
+
+        const collapseBtn = document.getElementById('collapseBtn');
+        if (collapseBtn) {
+            collapseBtn.addEventListener('click', toggleSidebar);
+        }
+
+        const expandBtn = document.getElementById('expandBtn');
+        if (expandBtn) {
+            expandBtn.addEventListener('click', toggleSidebar);
+        }
+
+        const recordBtn = document.getElementById('recordBtn');
+        if (recordBtn) recordBtn.addEventListener('click', toggleRecord);
+
+        document.addEventListener('keydown', (e) => {
+            if (e.target.tagName === 'INPUT') return;
+
+            switch(e.key) {
+                case 'ArrowUp':
+                    e.preventDefault();
+                    playPreviousChannel();
+                    break;
+                case 'ArrowDown':
+                    e.preventDefault();
+                    playNextChannel();
+                    break;
+                case 'f':
+                case 'F':
+                    e.preventDefault();
+                    if (dp) {
+                        dp.fullScreen.toggle();
+                    }
+                    break;
+            }
+        });
+    }
+
+    window.initPlayerPage = async function() {
+
+        const username = getCurrentUsername();
+        if (username && window.userDataSync) {
+            window.userDataSync.init(username);
+        }
+        loadFavorites();
+        loadChannels();
+
+
+        setTimeout(() => {
+            const success = initPlayer();
+            if (!success) {
+                setTimeout(initPlayer, 1000);
+            }
+        }, 100);
+
+        setupEventListeners();
+        checkAutoPlay();
+
+        updateCurrentTime();
+        setInterval(updateCurrentTime, 1000);
+    };
+
+    setTimeout(window.initPlayerPage, 0);
+
+    window.addEventListener('beforeunload', (e) => {
+        if (recorder.active) {
+            e.preventDefault();
+            e.returnValue = '正在录制中，确定离开吗？';
+            return e.returnValue;
+        }
+
+        if (dp) {
+            try {
+                dp.destroy();
+            } catch (e) {
+            }
+            dp = null;
+        }
+
+        if (epgUpdateInterval) {
+            clearInterval(epgUpdateInterval);
+            epgUpdateInterval = null;
+        }
+
+        if (sidebarEpgInterval) {
+            clearInterval(sidebarEpgInterval);
+            sidebarEpgInterval = null;
+        }
+    });
+
+    document.addEventListener('visibilitychange', () => {
+        if (document.hidden) {
+            if (sidebarEpgInterval) {
+                clearInterval(sidebarEpgInterval);
+            }
+        } else {
+            if (channels.length > 0) {
+                startSidebarEpgUpdate();
+            }
+        }
+    });
+
+})();
+</script>

user_manager.py

@@ -0,0 +1,556 @@
+import secrets
+import hashlib
+import json
+from datetime import datetime, timedelta
+from typing import Dict, List, Optional
+from pydantic import BaseModel
+from upstash_redis import Redis
+import os
+from dotenv import load_dotenv
+
+load_dotenv()
+
+AVAILABLE_BADGES = {
+    'vip_dog': {
+        'id': 'vip_dog',
+        'name': '尊贵狗牌',
+        'icon': '🏷️',
+        'gradient': 'linear-gradient(135deg, #FFD700 0%, #FFA500 100%)',
+        'color': '#8B4513',
+        'border': '#FFD700',
+        'glow': 'rgba(255, 215, 0, 0.5)'
+    },
+    'diamond': {
+        'id': 'diamond',
+        'name': '钻石会员',
+        'icon': '💎',
+        'gradient': 'linear-gradient(135deg, #B9F2FF 0%, #00D4FF 100%)',
+        'color': '#003D5C',
+        'border': '#00D4FF',
+        'glow': 'rgba(0, 212, 255, 0.5)'
+    },
+    'crown': {
+        'id': 'crown',
+        'name': '皇冠用户',
+        'icon': '👑',
+        'gradient': 'linear-gradient(135deg, #FFE66D 0%, #FFB800 100%)',
+        'color': '#8B4000',
+        'border': '#FFB800',
+        'glow': 'rgba(255, 184, 0, 0.5)'
+    },
+    'star': {
+        'id': 'star',
+        'name': '星标用户',
+        'icon': '⭐',
+        'gradient': 'linear-gradient(135deg, #FFF7A5 0%, #FFDF00 100%)',
+        'color': '#8B7500',
+        'border': '#FFDF00',
+        'glow': 'rgba(255, 223, 0, 0.5)'
+    },
+    'fire': {
+        'id': 'fire',
+        'name': '火焰用户',
+        'icon': '🔥',
+        'gradient': 'linear-gradient(135deg, #FF6B6B 0%, #EE5A24 100%)',
+        'color': '#8B0000',
+        'border': '#EE5A24',
+        'glow': 'rgba(238, 90, 36, 0.5)'
+    },
+    'rocket': {
+        'id': 'rocket',
+        'name': '火箭用户',
+        'icon': '🚀',
+        'gradient': 'linear-gradient(135deg, #4ECDC4 0%, #44A08D 100%)',
+        'color': '#0D4C4A',
+        'border': '#44A08D',
+        'glow': 'rgba(68, 160, 141, 0.5)'
+    },
+    'rainbow': {
+        'id': 'rainbow',
+        'name': '彩虹用户',
+        'icon': '🌈',
+        'gradient': 'linear-gradient(135deg, #667eea 0%, #764ba2 50%, #f093fb 100%)',
+        'color': '#4A148C',
+        'border': '#764ba2',
+        'glow': 'rgba(118, 75, 162, 0.5)'
+    }
+}
+
+class User(BaseModel):
+    # 基本信息
+    username: str
+    password_hash: str
+    created_at: datetime
+    expires_at: Optional[datetime] = None
+    last_login: Optional[datetime] = None
+    is_active: bool = True
+    is_admin: bool = False
+    created_by: str = "admin"
+    notes: str = ""
+    badge: Optional[str] = None
+    
+    # ✅ 用户设置（合并到用户模型）
+    favorite_channels: List[str] = []
+    download_concurrency: int = 16
+    batch_download_concurrency: int = 3
+    fab_position: Dict[str, float] = {'bottom': 30, 'right': 30}
+    playback_history: List[Dict] = []
+    program_reminders: List[Dict] = []
+    
+    class Config:
+        json_encoders = {
+            datetime: lambda v: v.isoformat() if v else None
+        }
+
+class UserManager:
+    def __init__(self):
+        redis_url = os.getenv('REDIS_URL', '')
+        redis_token = os.getenv('REDIS_TOKEN', '')
+        
+        if not redis_url or not redis_token:
+            self.redis = None
+            self.users: Dict[str, User] = {}
+        else:
+            try:
+                self.redis = Redis(url=redis_url, token=redis_token)
+                self.redis.ping()
+                self.users: Dict[str, User] = {}
+                self.load_all_users()
+            except Exception as e:
+                self.redis = None
+                self.users: Dict[str, User] = {}
+    
+    def _get_user_key(self, username: str) -> str:
+        return f"user:{username}"
+    
+    def _save_user_to_redis(self, user: User):
+        """保存用户到 Redis（包含所有设置）"""
+        if not self.redis:
+            return
+        
+        try:
+            user_dict = user.dict()
+            
+            # 转换 datetime
+            user_dict['created_at'] = user_dict['created_at'].isoformat()
+            if user_dict['expires_at']:
+                user_dict['expires_at'] = user_dict['expires_at'].isoformat()
+            if user_dict['last_login']:
+                user_dict['last_login'] = user_dict['last_login'].isoformat()
+            
+            user_json = json.dumps(user_dict)
+            self.redis.set(self._get_user_key(user.username), user_json)
+            self.redis.sadd("users:all", user.username)
+            
+            print(f"✅ 用户 {user.username} 已保存到 Redis（包含所有设置）")
+        except Exception as e:
+            print(f"❌ 保存用户失败: {e}")
+    
+    def _save_user_to_redis_with_retry(self, user: User, max_retries: int = 3):
+        """带重试机制的Redis保存"""
+        if not self.redis:
+            print(f"⚠️ Redis不可用，���过保存用户 {user.username}")
+            return False
+        
+        for attempt in range(max_retries):
+            try:
+                user_dict = user.dict()
+                
+                # 转换 datetime
+                user_dict['created_at'] = user_dict['created_at'].isoformat()
+                if user_dict['expires_at']:
+                    user_dict['expires_at'] = user_dict['expires_at'].isoformat()
+                if user_dict['last_login']:
+                    user_dict['last_login'] = user_dict['last_login'].isoformat()
+                
+                user_json = json.dumps(user_dict)
+                self.redis.set(self._get_user_key(user.username), user_json)
+                self.redis.sadd("users:all", user.username)
+                
+                print(f"✅ 用户 {user.username} 已保存到 Redis（重试第 {attempt + 1} 次成功）")
+                return True
+                
+            except Exception as e:
+                print(f"❌ 保存用户失败（第 {attempt + 1} 次重试）: {e}")
+                if attempt == max_retries - 1:
+                    print(f"❌ 用户 {user.username} 保存到 Redis 失败，已达最大重试次数")
+                    return False
+                import time
+                time.sleep(0.5 * (attempt + 1))  # 指数退避
+        
+        return False
+    
+    def _load_user_from_redis(self, username: str) -> Optional[User]:
+        """从 Redis 加载用户（包含所有设置）"""
+        if not self.redis:
+            return None
+        
+        try:
+            user_json = self.redis.get(self._get_user_key(username))
+            if not user_json:
+                return None
+            
+            user_dict = json.loads(user_json)
+            
+            # 转换 datetime
+            user_dict['created_at'] = datetime.fromisoformat(user_dict['created_at'])
+            if user_dict.get('expires_at'):
+                user_dict['expires_at'] = datetime.fromisoformat(user_dict['expires_at'])
+            if user_dict.get('last_login'):
+                user_dict['last_login'] = datetime.fromisoformat(user_dict['last_login'])
+            
+            # ✅ 兼容旧数据：如果没有新字段，使用默认值
+            if 'favorite_channels' not in user_dict:
+                user_dict['favorite_channels'] = []
+            if 'download_concurrency' not in user_dict:
+                user_dict['download_concurrency'] = 16
+            if 'batch_download_concurrency' not in user_dict:
+                user_dict['batch_download_concurrency'] = 3
+            if 'fab_position' not in user_dict:
+                user_dict['fab_position'] = {'bottom': 30, 'right': 30}
+            if 'playback_history' not in user_dict:
+                user_dict['playback_history'] = []
+            if 'program_reminders' not in user_dict:
+                user_dict['program_reminders'] = []
+            
+            user = User(**user_dict)
+            return user
+            
+        except Exception as e:
+            print(f"❌ 加载用户失败: {e}")
+            import traceback
+            traceback.print_exc()
+            return None
+    
+    def load_all_users(self):
+        """加载所有用户"""
+        if not self.redis:
+            return
+        
+        try:
+            usernames = self.redis.smembers("users:all")
+            if not usernames:
+                return
+            
+            for username in usernames:
+                user = self._load_user_from_redis(username)
+                if user:
+                    self.users[username] = user
+            
+            print(f"✅ 已加载 {len(self.users)} 个用户")
+        except Exception as e:
+            print(f"❌ 加载用户列表失败: {e}")
+    
+    def _delete_user_from_redis(self, username: str):
+        """从 Redis 删除用户"""
+        if not self.redis:
+            return
+        
+        try:
+            self.redis.delete(self._get_user_key(username))
+            self.redis.srem("users:all", username)
+        except Exception as e:
+            pass
+    
+    # ==================== 基本用户管理 ====================
+    
+    def generate_password(self, length: int = 12) -> str:
+        chars = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"
+        return ''.join(secrets.choice(chars) for _ in range(length))
+    
+    def hash_password(self, password: str) -> str:
+        return hashlib.sha256(password.encode()).hexdigest()
+    
+    def create_user(
+        self, 
+        username: str, 
+        password: Optional[str] = None,
+        expires_days: Optional[int] = None,
+        notes: str = "",
+        badge: Optional[str] = None,
+        is_admin: bool = False
+    ) -> tuple[User, str]:
+        if username in self.users:
+            raise ValueError(f"User {username} already exists")
+        
+        plain_password = password or self.generate_password()
+        password_hash = self.hash_password(plain_password)
+        
+        expires_at = None
+        if expires_days:
+            expires_at = datetime.now() + timedelta(days=expires_days)
+        
+        if badge and badge not in AVAILABLE_BADGES:
+            raise ValueError(f"Invalid badge: {badge}")
+        
+        user = User(
+            username=username,
+            password_hash=password_hash,
+            created_at=datetime.now(),
+            expires_at=expires_at,
+            notes=notes,
+            badge=badge,
+            is_admin=is_admin
+        )
+        
+        self.users[username] = user
+        # 实时保存到Redis
+        self._save_user_to_redis_with_retry(user)
+        
+        return user, plain_password
+    
+    def verify_user(self, username: str, password_hash: str) -> bool:
+        if username not in self.users:
+            user = self._load_user_from_redis(username)
+            if user:
+                self.users[username] = user
+            else:
+                return False
+        
+        user = self.users[username]
+        
+        if not user.is_active:
+            return False
+        
+        if user.expires_at and datetime.now() > user.expires_at:
+            user.is_active = False
+            self._save_user_to_redis(user)
+            return False
+        
+        if user.password_hash == password_hash:
+            user.last_login = datetime.now()
+            # 实时保存登录时间到Redis
+            self._save_user_to_redis_with_retry(user)
+            return True
+        
+        return False
+    
+    def delete_user(self, username: str) -> bool:
+        if username in self.users:
+            del self.users[username]
+            self._delete_user_from_redis(username)
+            return True
+        return False
+    
+    def deactivate_user(self, username: str) -> bool:
+        if username in self.users:
+            self.users[username].is_active = False
+            # 实时保存状态变更到Redis
+            self._save_user_to_redis_with_retry(self.users[username])
+            return True
+        return False
+    
+    def activate_user(self, username: str) -> bool:
+        if username in self.users:
+            self.users[username].is_active = True
+            # 实时保存状态变更到Redis
+            self._save_user_to_redis_with_retry(self.users[username])
+            return True
+        return False
+    
+    def extend_expiry(self, username: str, days: int) -> bool:
+        if username in self.users:
+            user = self.users[username]
+            if user.expires_at:
+                user.expires_at += timedelta(days=days)
+            else:
+                user.expires_at = datetime.now() + timedelta(days=days)
+            # 实时保存过期时间变更到Redis
+            self._save_user_to_redis_with_retry(user)
+            return True
+        return False
+    
+    def set_badge(self, username: str, badge: Optional[str]) -> bool:
+        if username not in self.users:
+            user = self._load_user_from_redis(username)
+            if user:
+                self.users[username] = user
+            else:
+                return False
+
+        if badge and badge not in AVAILABLE_BADGES:
+            raise ValueError(f"Invalid badge: {badge}")
+
+        self.users[username].badge = badge
+        # 实时保存徽章变更到Redis
+        self._save_user_to_redis_with_retry(self.users[username])
+        return True
+    
+    # ==================== 用户设置管理（直接操作用户对象）====================
+    
+    def get_user_data(self, username: str) -> Optional[Dict]:
+        """获取用户完整数据（包含设置）"""
+        if username not in self.users:
+            user = self._load_user_from_redis(username)
+            if user:
+                self.users[username] = user
+            else:
+                return None
+        
+        user = self.users[username]
+        return {
+            'favorite_channels': user.favorite_channels,
+            'download_concurrency': user.download_concurrency,
+            'batch_download_concurrency': user.batch_download_concurrency,
+            'fab_position': user.fab_position,
+            'playback_history': user.playback_history,
+            'program_reminders': user.program_reminders
+        }
+    
+    def get_user_settings(self, username: str) -> Dict:
+        """获取用户设置（兼容旧API）"""
+        data = self.get_user_data(username)
+        if data is None:
+            # 如果用户不存在，返回默认设置
+            return {
+                'favorite_channels': [],
+                'download_concurrency': 16,
+                'batch_download_concurrency': 3,
+                'fab_position': {'bottom': 30, 'right': 30},
+                'playback_history': [],
+                'program_reminders': []
+            }
+        return data
+    
+    def delete_user_settings(self, username: str) -> bool:
+        """删除用户设置（重置为默认值）"""
+        if username not in self.users:
+            user = self._load_user_from_redis(username)
+            if user:
+                self.users[username] = user
+            else:
+                return False
+        
+        # 重置用户设置为默认值
+        user = self.users[username]
+        user.favorite_channels = []
+        user.download_concurrency = 16
+        user.batch_download_concurrency = 3
+        user.fab_position = {'bottom': 30, 'right': 30}
+        user.playback_history = []
+        user.program_reminders = []
+        
+        # 实时保存到Redis
+        self._save_user_to_redis_with_retry(user)
+        print(f"✅ 用户 {username} 设置已重置为默认值")
+        return True
+    
+    def update_user_data(self, username: str, data: Dict) -> bool:
+        """更新用户数据（增量更新）"""
+        if username not in self.users:
+            user = self._load_user_from_redis(username)
+            if user:
+                self.users[username] = user
+            else:
+                return False
+        
+        user = self.users[username]
+        
+        # ✅ 只更新传入的字段
+        if 'favorite_channels' in data:
+            user.favorite_channels = data['favorite_channels']
+        if 'download_concurrency' in data:
+            user.download_concurrency = data['download_concurrency']
+        if 'batch_download_concurrency' in data:
+            user.batch_download_concurrency = data['batch_download_concurrency']
+        if 'fab_position' in data:
+            user.fab_position = data['fab_position']
+        if 'playback_history' in data:
+            user.playback_history = data['playback_history']
+        if 'program_reminders' in data:
+            user.program_reminders = data['program_reminders']
+        
+        # 实时保存用户行为数据到Redis
+        self._save_user_to_redis_with_retry(user)
+        print(f"✅ 用户 {username} 数据已实时保存到Redis: {list(data.keys())}")
+        return True
+    
+    # ==================== 便捷方法 ====================
+    
+    def get_favorites(self, username: str) -> List[str]:
+        """获取收藏频道"""
+        data = self.get_user_data(username)
+        return data['favorite_channels'] if data else []
+    
+    def set_favorites(self, username: str, favorites: List[str]) -> bool:
+        """设置收藏频道"""
+        return self.update_user_data(username, {'favorite_channels': favorites})
+    
+    def get_download_concurrency(self, username: str) -> int:
+        """获取下载并发数"""
+        data = self.get_user_data(username)
+        return data['download_concurrency'] if data else 16
+    
+    def set_download_concurrency(self, username: str, concurrency: int) -> bool:
+        """设置下载并发数"""
+        return self.update_user_data(username, {'download_concurrency': concurrency})
+    
+    def get_batch_concurrency(self, username: str) -> int:
+        """获取批量并发数"""
+        data = self.get_user_data(username)
+        return data['batch_download_concurrency'] if data else 3
+    
+    def set_batch_concurrency(self, username: str, concurrency: int) -> bool:
+        """设置批量并发数"""
+        return self.update_user_data(username, {'batch_download_concurrency': concurrency})
+    
+    def get_fab_position(self, username: str) -> Dict[str, float]:
+        """获取 FAB 位置"""
+        data = self.get_user_data(username)
+        return data['fab_position'] if data else {'bottom': 30, 'right': 30}
+    
+    def set_fab_position(self, username: str, position: Dict[str, float]) -> bool:
+        """设置 FAB 位置"""
+        return self.update_user_data(username, {'fab_position': position})
+    
+    def get_user(self, username: str) -> Optional[User]:
+        if username in self.users:
+            return self.users[username]
+        
+        user = self._load_user_from_redis(username)
+        if user:
+            self.users[username] = user
+        return user
+    
+    def list_users(self) -> List[User]:
+        try:
+            if self.redis:
+                self.load_all_users()
+            
+            users = list(self.users.values())
+            return users
+        except Exception as e:
+            import traceback
+            traceback.print_exc()
+            return []
+    
+    def get_stats(self) -> dict:
+        try:
+            if self.redis:
+                self.load_all_users()
+            
+            total = len(self.users)
+            active = sum(1 for u in self.users.values() if u.is_active)
+            expired = sum(1 for u in self.users.values() 
+                         if u.expires_at and datetime.now() > u.expires_at)
+            
+            return {
+                "total": total,
+                "active": active,
+                "expired": expired,
+                "inactive": total - active,
+                "storage": "Redis (Upstash)" if self.redis else "Memory (临时)"
+            }
+        except Exception as e:
+            return {
+                "total": 0,
+                "active": 0,
+                "expired": 0,
+                "inactive": 0,
+                "storage": "Error"
+            }
+    
+    def get_available_badges(self) -> dict:
+        return AVAILABLE_BADGES
+
+user_manager = UserManager()

utils.py

@@ -0,0 +1,343 @@
+import json
+import httpx
+from datetime import datetime, timedelta, timezone
+from typing import Optional, Dict, Any
+from urllib.parse import urlparse
+from config import Config
+from cache_manager import cache
+
+async def get_cid(force: bool = False) -> str:
+    if not force:
+        cached = cache.get_cid()
+        if cached:
+            return cached
+    
+    try:
+        url = Config.get_cid_url()
+        
+        async with httpx.AsyncClient(timeout=Config.TIMEOUT) as client:
+            response = await client.get(url)
+            response.raise_for_status()
+            data = response.json()
+            
+            if 'cid' not in data:
+                raise ValueError("CID not found in response")
+            
+            cid = data['cid']
+            cache.set_cid(cid)
+            return cid
+    
+    except Exception as e:
+        if cache.cid:
+            return cache.cid
+        raise e
+
+async def get_auth(force: bool = False, retry_count: int = 0) -> Dict[str, Any]:
+    if not force:
+        cached = cache.get_auth()
+        if cached:
+            return cached
+    
+    try:
+        cid = await get_cid(force=(retry_count > 0))
+        
+        login_url = Config.get_login_url(cid)
+        
+        async with httpx.AsyncClient(timeout=Config.TIMEOUT) as client:
+            response = await client.get(login_url)
+            response.raise_for_status()
+            data = response.json()
+            
+            if data.get('code') != 'OK':
+                error_msg = data.get('message', 'Unknown error')
+                
+                if 'cid' in error_msg.lower() and retry_count < 2:
+                    return await get_auth(force=True, retry_count=retry_count + 1)
+                
+                raise ValueError(f"Login failed: {error_msg}")
+            
+            product_config = json.loads(data.get('product_config', '{}'))
+            
+            auth = {
+                'access_token': data['access_token'],
+                'vms_host': product_config['vms_host'].rstrip('/'),
+                'vms_uid': product_config['vms_uid']
+            }
+            
+            if not all(auth.values()):
+                raise ValueError("Incomplete auth data")
+            
+            cache.set_auth(auth)
+            return auth
+    
+    except Exception as e:
+        if cache.auth and retry_count == 0:
+            return cache.auth
+        raise e
+
+async def get_channels(auth: Dict[str, Any], force: bool = False) -> list:
+    if not force:
+        cached = cache.get_channels()
+        if cached:
+            return cached
+    
+    try:
+        url = Config.get_list_url(auth['vms_uid'], with_epg=False)
+        
+        headers = {
+            'Referer': Config.REQUIRED_REFERER,
+            'User-Agent': 'Mozilla/5.0'
+        }
+        
+        async with httpx.AsyncClient(timeout=Config.TIMEOUT) as client:
+            response = await client.get(url, headers=headers)
+            response.raise_for_status()
+            data = response.json()
+            
+            channels = [
+                ch for ch in data.get('result', [])
+                if ch.get('id') and ch.get('no') and ch.get('name') and ch.get('playpath')
+            ]
+            
+            if not channels:
+                raise ValueError("No channels found")
+            
+            cache.set_channels(channels)
+            return channels
+    
+    except httpx.HTTPStatusError as e:
+        if e.response.status_code in [401, 403]:
+            new_auth = await get_auth(force=True)
+            return await get_channels(new_auth, force=True)
+        raise e
+    
+    except Exception as e:
+        if cache.channels:
+            return cache.channels
+        raise e
+
+async def fetch_epg(vid: str, date: str, auth: dict, retry_count: int = 0) -> list:
+    """获取EPG数据，优先从缓存读取"""
+    # 先检查缓存
+    cached = cache.get_epg(vid, date)
+    if cached is not None:
+        return cached
+
+    # 缓存未命中，从API获取
+    try:
+        url = Config.get_epg_url(auth['vms_uid'], vid)
+
+        headers = {
+            'Referer': Config.REQUIRED_REFERER,
+            'User-Agent': 'Mozilla/5.0'
+        }
+
+        async with httpx.AsyncClient(timeout=Config.TIMEOUT) as client:
+            response = await client.get(url, headers=headers)
+
+            if response.status_code in [401, 403] and retry_count < 2:
+                new_auth = await get_auth(force=True)
+                return await fetch_epg(vid, date, new_auth, retry_count + 1)
+            
+            response.raise_for_status()
+            data = response.json()
+
+            if not data.get('result') or not data['result'][0].get('record_epg'):
+                # 空数据也缓存
+                cache.set_epg(vid, date, [])
+                return []
+
+            full_epg = json.loads(data['result'][0]['record_epg'])
+
+            # 处理节目数据
+            processed_epg = []
+            for i, program in enumerate(full_epg):
+                if not program.get('time'):
+                    continue
+
+                if 'time_end' not in program or not program['time_end']:
+                    if i + 1 < len(full_epg) and full_epg[i + 1].get('time'):
+                        program['time_end'] = full_epg[i + 1]['time']
+                    else:
+                        continue
+
+                processed_epg.append(program)
+
+            # 按天分组缓存
+            daily_epg = {}
+            for program in processed_epg:
+                dt = datetime.fromtimestamp(program['time'])
+                date_str = get_jst_date(dt)
+
+                if date_str not in daily_epg:
+                    daily_epg[date_str] = []
+                daily_epg[date_str].append(program)
+
+            # 缓存所有日期的数据
+            for d, programs in daily_epg.items():
+                sorted_programs = sorted(programs, key=lambda x: x['time'])
+                cache.set_epg(vid, d, sorted_programs)
+
+            # 返回请求的日期数据
+            result = daily_epg.get(date, [])
+            if result:
+                return sorted(result, key=lambda x: x['time'])
+            else:
+                # 如果请求的日期没有数据，也缓存空结果
+                if date not in daily_epg:
+                    cache.set_epg(vid, date, [])
+                return []
+
+    except Exception as e:
+        raise e
+
+
+async def get_all_epg(auth: Dict[str, Any], force: bool = False) -> Dict[str, list]:
+    """获取所有频道的EPG数据，优先使用缓存"""
+    # 检查全量缓存
+    if not force:
+        cached = cache.get_epg('_all_', 'full')
+        if cached:
+            return cached
+
+    # 从API获取全量数据
+    try:
+        url = Config.get_list_url(auth['vms_uid'], with_epg=True)
+
+        headers = {
+            'Referer': Config.REQUIRED_REFERER,
+            'User-Agent': 'Mozilla/5.0'
+        }
+
+        async with httpx.AsyncClient(timeout=Config.TIMEOUT) as client:
+            response = await client.get(url, headers=headers)
+            response.raise_for_status()
+            data = response.json()
+
+            result = {}
+
+            for channel in data.get('result', []):
+                channel_id = channel.get('id')
+                record_epg = channel.get('record_epg')
+
+                if not channel_id:
+                    continue
+
+                if not record_epg:
+                    result[channel_id] = []
+                    continue
+
+                try:
+                    epg_list = json.loads(record_epg)
+
+                    processed_programs = []
+                    for i, program in enumerate(epg_list):
+                        if not program.get('time'):
+                            continue
+
+                        if 'time_end' not in program or not program['time_end']:
+                            if i + 1 < len(epg_list) and epg_list[i + 1].get('time'):
+                                program['time_end'] = epg_list[i + 1]['time']
+                            else:
+                                continue
+
+                        processed_programs.append(program)
+
+                    # 按天分组缓存
+                    daily_epg = {}
+                    for program in processed_programs:
+                        dt = datetime.fromtimestamp(program['time'])
+                        date_str = get_jst_date(dt)
+
+                        if date_str not in daily_epg:
+                            daily_epg[date_str] = []
+                        daily_epg[date_str].append(program)
+
+                    # 缓存每一天的数据
+                    for date, programs in daily_epg.items():
+                        sorted_programs = sorted(programs, key=lambda x: x['time'])
+                        cache.set_epg(channel_id, date, sorted_programs)
+
+                    result[channel_id] = processed_programs
+
+                except json.JSONDecodeError:
+                    result[channel_id] = []
+                    continue
+
+            # 缓存全量数据
+            cache.set_epg('_all_', 'full', result)
+
+            return result
+
+    except Exception as e:
+        # 如果有缓存，返回缓存
+        cached = cache.get_epg('_all_', 'full')
+        if cached:
+            return cached
+        return {}
+
+
+def get_jst_date(dt: Optional[datetime] = None) -> str:
+    if dt is None:
+        dt = datetime.now()
+    
+    jst = timezone(timedelta(hours=9))
+    jst_time = dt.astimezone(jst)
+    return jst_time.strftime('%Y-%m-%d')
+
+def rewrite_m3u8(content: str, current_path: str, worker_base: str) -> str:
+    lines = content.split('\n')
+    output = []
+    
+    if '?' in current_path:
+        base_path_part, query_part = current_path.rsplit('?', 1)
+        base_dir = base_path_part[:base_path_part.rfind('/') + 1]
+    else:
+        base_dir = current_path[:current_path.rfind('/') + 1]
+        query_part = ''
+    
+    for line in lines:
+        trimmed = line.strip()
+        
+        if trimmed.startswith('#') or not trimmed:
+            output.append(line)
+            continue
+        
+        if trimmed.startswith('http://') or trimmed.startswith('https://'):
+            parsed = urlparse(trimmed)
+            target_path = parsed.path
+            if parsed.query:
+                target_path += f"?{parsed.query}"
+            
+        elif trimmed.startswith('/'):
+            target_path = trimmed
+            
+        else:
+            target_path = base_dir + trimmed
+            
+            if '?' not in target_path and query_part:
+                target_path += f"?{query_part}"
+        
+        output.append(worker_base + target_path)
+    
+    return '\n'.join(output)
+
+def extract_playlist_url(content: str, base_url: str) -> Optional[str]:
+    for line in content.split('\n'):
+        trimmed = line.strip()
+        
+        if not trimmed or trimmed.startswith('#'):
+            continue
+        
+        if trimmed.startswith('http'):
+            return trimmed
+        
+        if trimmed.endswith('.m3u8') or trimmed.endswith('.M3U8'):
+            parsed = urlparse(base_url)
+            if trimmed.startswith('/'):
+                return f"{parsed.scheme}://{parsed.netloc}{trimmed}"
+            else:
+                base_path = base_url[:base_url.rfind('/') + 1]
+                return base_path + trimmed
+    
+    return None