merge: feat/admin-panel into master

- Add Chinese admin panel with Ghost Terminal design
- Add mute detection (shows mute status and expiry)
- Add dual-column layout with built-in API testing
- Keep browser automation with CloakBrowser

account_manager.py

@@ -3,7 +3,7 @@ from collections import deque
 from dataclasses import dataclass, field
 from typing import Dict, Optional
 
-from deepseek_api import DeepSeekAPI
+from deepseek_browser import DeepSeekBrowser
 
 
 @dataclass
@@ -12,18 +12,19 @@ class Account:
     password: str
     name: str = ""
     proxy: Optional[str] = None
-    api: Optional[DeepSeekAPI] = field(default=None, repr=False)
-    in_use_count: int = 0
-    max_concurrent: int = 3
+    browser: Optional[DeepSeekBrowser] = field(default=None, repr=False)
+    in_use: bool = False
     error_count: int = 0
     logged_in: bool = False
+    is_muted: bool = False
+    muted_until: str = ""
 
 
 class AccountManager:
-    def __init__(self, max_concurrent_per_account: int = 3):
+    def __init__(self, max_inflight: int = 1):
         self.accounts: Dict[str, Account] = {}
         self.queue: deque = deque()
-        self.max_concurrent_per_account = max_concurrent_per_account
+        self.max_inflight = max_inflight
         self._lock = asyncio.Lock()
 
     def add_account(self, email: str, password: str, name: str = "", proxy: Optional[str] = None):
@@ -32,14 +33,13 @@ class AccountManager:
             password=password,
             name=name,
             proxy=proxy,
-            max_concurrent=self.max_concurrent_per_account,
         )
 
     async def acquire(self) -> Account:
         async with self._lock:
             for account in self.accounts.values():
-                if account.in_use_count < account.max_concurrent and account.error_count < 3:
-                    account.in_use_count += 1
+                if not account.in_use and account.error_count < 3:
+                    account.in_use = True
                     return account
 
         return await self._wait_for_account()
@@ -53,15 +53,15 @@ class AccountManager:
 
         async with self._lock:
             for account in self.accounts.values():
-                if account.in_use_count < account.max_concurrent and account.error_count < 3:
-                    account.in_use_count += 1
+                if not account.in_use and account.error_count < 3:
+                    account.in_use = True
                     return account
 
         raise RuntimeError("No account available")
 
     async def release(self, account: Account):
         async with self._lock:
-            account.in_use_count = max(0, account.in_use_count - 1)
+            account.in_use = False
             if self.queue:
                 event = self.queue.popleft()
                 event.set()
@@ -69,53 +69,73 @@ class AccountManager:
     async def mark_error(self, account: Account):
         async with self._lock:
             account.error_count += 1
-            account.in_use_count = max(0, account.in_use_count - 1)
+            account.in_use = False
             if self.queue:
                 event = self.queue.popleft()
                 event.set()
 
-    async def get_api(self, account: Account) -> DeepSeekAPI:
+    async def get_or_create_browser(self, account: Account, headless: bool = True) -> DeepSeekBrowser:
         try:
-            if account.api is None:
-                account.api = DeepSeekAPI(
+            if account.browser is None:
+                account.browser = DeepSeekBrowser(
                     email=account.email,
                     password=account.password,
+                    profile_dir="./profiles",
+                    headless=headless,
+                    humanize=True,
                     proxy=account.proxy,
                 )
-                await account.api.login()
+                await account.browser.start()
                 account.logged_in = True
-            return account.api
+                # Check mute status
+                account.is_muted = account.browser.is_muted()
+                account.muted_until = account.browser.muted_until()
+            return account.browser
         except Exception as e:
-            print(f"Error creating API: {e}")
-            await self.close_api(account)
+            print(f"Error creating browser: {e}")
+            await self.close_browser(account)
             raise
 
-    async def get_api_with_retry(self, account: Account) -> DeepSeekAPI:
+    async def get_or_create_browser_with_retry(self, account: Account, headless: bool = True) -> DeepSeekBrowser:
         try:
-            return await self.get_api(account)
+            return await self.get_or_create_browser(account, headless)
         except Exception:
-            await self.close_api(account)
-            return await self.get_api(account)
+            await self.close_browser(account)
+            return await self.get_or_create_browser(account, headless)
 
-    async def close_api(self, account: Account):
-        if account.api:
+    async def close_browser(self, account: Account):
+        if account.browser:
             try:
-                await account.api.close()
+                await account.browser.close()
             except:
                 pass
-            account.api = None
+            account.browser = None
             account.logged_in = False
 
     def get_stats(self) -> Dict:
         total = len(self.accounts)
-        in_use = sum(a.in_use_count for a in self.accounts.values())
-        available = sum(1 for a in self.accounts.values() if a.in_use_count < a.max_concurrent and a.error_count < 3)
+        in_use = sum(1 for a in self.accounts.values() if a.in_use)
+        available = sum(1 for a in self.accounts.values() if not a.in_use and a.error_count < 3)
         logged_in = sum(1 for a in self.accounts.values() if a.logged_in)
+        muted = sum(1 for a in self.accounts.values() if a.is_muted)
+        accounts_list = [
+            {
+                "email": a.email,
+                "name": a.name,
+                "in_use": a.in_use,
+                "logged_in": a.logged_in,
+                "is_muted": a.is_muted,
+                "muted_until": a.muted_until,
+                "error_count": a.error_count,
+            }
+            for a in self.accounts.values()
+        ]
         return {
             "total": total,
             "in_use": in_use,
             "available": available,
             "logged_in": logged_in,
+            "muted": muted,
             "queue_size": len(self.queue),
-            "max_concurrent_per_account": self.max_concurrent_per_account,
+            "accounts": accounts_list,
         }

config.py

@@ -43,7 +43,7 @@ class Config:
         account_str = os.getenv("DS2API_ACCOUNTS", "")
         if account_str:
             for acc in account_str.split(";"):
-                parts = acc.split(":")
+                parts = acc.split(":", 3)
                 if len(parts) >= 2:
                     accounts.append(AccountConfig(
                         email=parts[0],

deepseek_browser.py

@@ -1,19 +1,14 @@
 import asyncio
 import random
 import time
-import uuid
 from pathlib import Path
 from typing import AsyncGenerator, Optional
 
-import httpx
 from cloakbrowser import launch_persistent_context_async
 
 
 class DeepSeekBrowser:
     DEEPSEEK_URL = "https://chat.deepseek.com"
-    LOGIN_URL = "https://chat.deepseek.com/api/v0/users/login"
-    CREATE_SESSION_URL = "https://chat.deepseek.com/api/v0/chat_session/create"
-    COMPLETION_URL = "https://chat.deepseek.com/api/v0/chat/completion"
 
     def __init__(
         self,
@@ -34,15 +29,10 @@ class DeepSeekBrowser:
         self.page = None
         self._logged_in = False
         self._ready = False
-        self._token = None
-        self._session_id = None
 
     async def start(self):
         self.profile_dir.mkdir(parents=True, exist_ok=True)
 
-        # 先用 API 登录获取 token
-        await self._login_via_api()
-
         self.context = await launch_persistent_context_async(
             user_data_dir=str(self.profile_dir),
             headless=self.headless,
@@ -53,67 +43,95 @@ class DeepSeekBrowser:
         )
 
         self.page = await self.context.new_page()
-        
-        # 设置 token cookie
-        if self._token:
-            await self.context.add_cookies([{
-                "name": "token",
-                "value": self._token,
-                "domain": ".deepseek.com",
-                "path": "/",
-            }])
-
         await self.page.goto(self.DEEPSEEK_URL, timeout=60000)
-        await asyncio.sleep(3)
+        await asyncio.sleep(5)
+
+        await self._check_login_state()
+
+    async def _check_login_state(self):
+        current_url = self.page.url
+
+        if '/sign_in' in current_url:
+            await self._auto_login()
+        else:
+            try:
+                await self.page.wait_for_selector('textarea', timeout=10000)
+                self._logged_in = True
+                self._ready = True
+            except Exception:
+                await self._auto_login()
 
-        # 检查是否登录成功
-        if '/sign_in' in self.page.url:
-            # 如果 cookie 方式失败，尝试通过 JS 注入 token
-            await self.page.evaluate(f"localStorage.setItem('token', '{self._token}')")
-            await self.page.reload()
+        # Check if account is muted after login
+        if self._logged_in:
+            await self._check_mute()
+
+    async def _check_mute(self):
+        """Check if account is muted and extract mute expiry."""
+        try:
+            muted, until = await self.page.evaluate("""() => {
+                const text = document.body.innerText || '';
+                // Match: 禁言至 YYYY年M月D日 HH:MM or 禁言至 YYYY-MM-DD HH:MM
+                const match = text.match(/禁言至\\s*(\\d{4}[-年]\\d{1,2}[-月]\\d{1,2}[日]?\\s*\\d{1,2}:\\d{2})/);
+                if (match) return [true, match[1]];
+                if (text.includes('禁言')) return [true, ''];
+                return [false, ''];
+            }""")
+            self._is_muted = muted
+            self._muted_until = until
+            if muted:
+                print(f"[mute] {self.email} is muted until {until}")
+        except Exception:
+            self._is_muted = False
+            self._muted_until = ""
+
+    def is_muted(self) -> bool:
+        return getattr(self, '_is_muted', False)
+
+    def muted_until(self) -> str:
+        return getattr(self, '_muted_until', "")
+
+    async def _auto_login(self):
+        print(f"Logging in as {self.email}...")
+
+        try:
+            email_input = self.page.locator('input[placeholder*="邮箱"], input[placeholder*="手机"], input[placeholder*="Email"], input[placeholder*="email"], input[type="text"]').first
+            await email_input.wait_for(state="visible", timeout=10000)
+            await email_input.fill(self.email)
+            await asyncio.sleep(0.5)
+        except Exception as e:
+            # Take screenshot to debug
+            try:
+                await self.page.screenshot(path=f"/tmp/login_fail_{self.email.replace('@','_at_')}.png")
+                print(f"Screenshot saved to /tmp/login_fail_{self.email.replace('@','_at_')}.png")
+            except Exception:
+                pass
+            print(f"Email input error: {e}")
+            raise
+
+        try:
+            password_input = self.page.locator('input[type="password"]').first
+            await password_input.wait_for(state="visible", timeout=5000)
+            await password_input.fill(self.password)
+            await asyncio.sleep(0.5)
+        except Exception as e:
+            print(f"Password input error: {e}")
+            raise
+
+        try:
+            login_button = self.page.locator('button:has-text("登录")').first
+            await login_button.click()
             await asyncio.sleep(3)
+        except Exception as e:
+            print(f"Login button error: {e}")
+            raise
 
-        if '/sign_in' not in self.page.url:
+        try:
+            await self.page.wait_for_selector('textarea', timeout=30000)
             self._logged_in = True
             self._ready = True
-        else:
-            raise Exception("Login failed - still on sign_in page")
-
-    async def _login_via_api(self):
-        """通过 DeepSeek API 登录获取 token"""
-        async with httpx.AsyncClient() as client:
-            device_id = str(uuid.uuid4())
-            payload = {
-                "email": self.email,
-                "password": self.password,
-                "device_id": device_id,
-                "os": "android",
-            }
-            
-            headers = {
-                "Content-Type": "application/json",
-                "User-Agent": "DeepSeek-Android/2.0",
-            }
-            
-            resp = await client.post(self.LOGIN_URL, json=payload, headers=headers, timeout=30)
-            data = resp.json()
-            
-            code = data.get("code", -1)
-            if code != 0:
-                msg = data.get("msg", "Unknown error")
-                raise Exception(f"API login failed: {msg}")
-            
-            biz_data = data.get("data", {})
-            biz_code = biz_data.get("biz_code", -1)
-            if biz_code != 0:
-                biz_msg = biz_data.get("biz_msg", "Unknown error")
-                raise Exception(f"API login failed: {biz_msg}")
-            
-            user = biz_data.get("biz_data", {}).get("user", {})
-            self._token = user.get("token", "")
-            
-            if not self._token:
-                raise Exception("No token received from API")
+            print("Login successful!")
+        except Exception:
+            raise Exception("Login failed")
 
     async def _human_delay(self, min_ms: int = 300, max_ms: int = 1500):
         delay = random.uniform(min_ms, max_ms) / 1000
@@ -130,26 +148,102 @@ class DeepSeekBrowser:
 
     async def delete_chat(self):
         try:
-            more_btn = self.page.locator('button:has-text("更多"), .ds-icon-button:has-text("...")').first
-            if await more_btn.count() > 0:
-                await more_btn.click()
-                await asyncio.sleep(0.5)
-
-                delete_btn = self.page.locator('button:has-text("删除"), div:has-text("删除对话")').first
-                if await delete_btn.count() > 0:
-                    await delete_btn.click()
-                    await asyncio.sleep(0.5)
+            # Find the sidebar and active conversation
+            chat_list = self.page.locator(
+                'nav, aside, [class*="sidebar"], [class*="Sidebar"], div:has-text("开启新对话")'
+            ).first
+            chat_list_count = await chat_list.count()
+            if chat_list_count == 0:
+                print(f"[delete_chat] no sidebar")
+                return
+
+            active_item = chat_list.locator(
+                '[class*="active"], [class*="selected"], [class*="current"]'
+            ).first
+            active_count = await active_item.count()
+            if active_count == 0:
+                # No active item yet (first chat), skip deletion
+                print(f"[delete_chat] no active item, skipping")
+                return
+
+            # Get bounding box and click near right edge where "..." should be
+            box = await active_item.bounding_box()
+            if not box:
+                print(f"[delete_chat] no bbox")
+                return
+
+            # Instead of position-based click, find the "..." element in DOM
+            click_result = await self.page.evaluate("""() => {
+                // Find the active/highlighted conversation item
+                const active = document.querySelector('[class*="active"], [class*="selected"]');
+                if (!active) return 'no-active';
+                
+                // Walk down to find a clickable child that looks like "..."
+                // The "..." is often a button or div with no text (SVG only)
+                const walk = (node, depth) => {
+                    if (depth > 10) return null;
+                    for (const child of node.children || []) {
+                        const tag = child.tagName;
+                        const cls = (child.className || '').toString();
+                        // Look for small icon-like elements
+                        if ((tag === 'BUTTON' || tag === 'svg' || cls.includes('icon') || cls.includes('more') || cls.includes('menu') || cls.includes('action')) && 
+                            child.offsetWidth < 40 && child.offsetWidth > 0) {
+                            return child;
+                        }
+                        const found = walk(child, depth + 1);
+                        if (found) return found;
+                    }
+                    return null;
+                };
+                
+                const icon = walk(active, 0);
+                if (icon) {
+                    icon.click();
+                    return 'clicked:' + icon.tagName + ':' + (icon.className || '').substring(0, 40);
+                }
+                
+                // Fallback: find any button/svg in active item
+                const btn = active.querySelector('button, [role="button"]');
+                if (btn) {
+                    btn.click();
+                    return 'fallback:' + btn.tagName;
+                }
+                return 'no-icon';
+            }""")
+            print(f"[delete_chat] icon click: {click_result}")
+            await asyncio.sleep(0.5)
 
-                    confirm_btn = self.page.locator('button:has-text("确认"), button:has-text("删除")').last
-                    if await confirm_btn.count() > 0:
-                        await confirm_btn.click()
-                        await asyncio.sleep(1)
-        except Exception:
-            pass
+            # Search for "删除" or "Delete" anywhere on page
+            delete_btn = self.page.locator(
+                ':has-text("删除"), :has-text("Delete")'
+            ).first
+            delete_count = await delete_btn.count()
+            
+            if delete_count == 0:
+                print(f"[delete_chat] no delete option found")
+                return
+
+            await delete_btn.click()
+            await asyncio.sleep(0.5)
+
+            # Confirm
+            confirm_btn = self.page.locator(
+                'button:has-text("确认"), button:has-text("删除"), '
+                'button:has-text("Confirm"), button:has-text("Delete")'
+            ).last
+            if await confirm_btn.count() > 0:
+                await confirm_btn.click()
+                await asyncio.sleep(1)
+                print(f"[delete_chat] done!")
+            else:
+                print(f"[delete_chat] no confirm btn")
+                
+        except Exception as e:
+            print(f"[delete_chat] error: {e}")
 
     async def switch_model(self, model: str):
         try:
-            if 'reasoner' in model or 'thinking' in model:
+            if 'reasoner' in model or 'thinking' in model or 'pro' in model:
                 thinking_btn = self.page.locator('button:has-text("深度思考"), div:has-text("深度思考")').first
                 if await thinking_btn.count() > 0:
                     await thinking_btn.click()
@@ -197,37 +291,35 @@ class DeepSeekBrowser:
         last_text = ""
         stable_count = 0
 
-        skip_phrases = ['深度思考', '智能搜索', '快速模式', '专家模式', '内容由 AI 生成', '开启新对话', '暂无历史对话']
+        skip_phrases = ['深度思考', '智能搜索', '快速模式', '专家模式', '内容由 AI 生成', '开启新对话', '暂无历史对话', '今天', 'huan********dja@gmail.com']
 
         while time.time() < deadline:
             try:
-                try:
-                    response_elements = await self.page.query_selector_all('.ds-markdown--block')
-                    if response_elements:
-                        last_response = response_elements[-1]
-                        current_text = await last_response.inner_text()
-                        current_text = current_text.strip()
-                    else:
-                        main_content = await self.page.query_selector('main, .chat-container, [class*="chat"]')
-                        if main_content:
-                            current_text = await main_content.inner_text()
-                        else:
-                            current_text = await self.page.inner_text('body')
-                except Exception:
-                    current_text = await self.page.inner_text('body')
+                text = await self.page.inner_text('body')
+
+                lines = text.split('\n')
+                response_started = False
+                response_text = []
 
-                lines = current_text.split('\n')
-                filtered_lines = []
                 for line in lines:
                     line = line.strip()
                     if not line:
                         continue
+
+                    if line == '内容由 AI 生成，请仔细甄别':
+                        break
+
                     if any(phrase in line for phrase in skip_phrases):
                         continue
-                    filtered_lines.append(line)
 
-                if filtered_lines:
-                    current_text = '\n'.join(filtered_lines)
+                    if response_started:
+                        response_text.append(line)
+
+                    if prompt and prompt in line:
+                        response_started = True
+
+                if response_text:
+                    current_text = '\n'.join(response_text)
 
                     if current_text != last_text:
                         last_text = current_text
@@ -269,39 +361,37 @@ class DeepSeekBrowser:
             last_text = ""
             stable_count = 0
 
-            skip_phrases = ['深度思考', '智能搜索', '快速模式', '专家模式', '内容由 AI 生成', '开启新对话', '暂无历史对话']
+            skip_phrases = ['深度思考', '智能搜索', '快速模式', '专家模式', '内容由 AI 生成', '开启新对话', '暂无历史对话', '今天', 'huan********dja@gmail.com']
 
             await asyncio.sleep(3)
 
             while time.time() < deadline:
                 try:
-                    try:
-                        response_elements = await self.page.query_selector_all('.ds-markdown--block')
-                        if response_elements:
-                            last_response = response_elements[-1]
-                            current_text = await last_response.inner_text()
-                            current_text = current_text.strip()
-                        else:
-                            main_content = await self.page.query_selector('main, .chat-container, [class*="chat"]')
-                            if main_content:
-                                current_text = await main_content.inner_text()
-                            else:
-                                current_text = await self.page.inner_text('body')
-                    except Exception:
-                        current_text = await self.page.inner_text('body')
-
-                    lines = current_text.split('\n')
-                    filtered_lines = []
+                    text = await self.page.inner_text('body')
+
+                    lines = text.split('\n')
+                    response_started = False
+                    response_text = []
+
                     for line in lines:
                         line = line.strip()
                         if not line:
                             continue
+
+                        if line == '内容由 AI 生成，请仔细甄别':
+                            break
+
                         if any(phrase in line for phrase in skip_phrases):
                             continue
-                        filtered_lines.append(line)
 
-                    if filtered_lines:
-                        current_text = '\n'.join(filtered_lines)
+                        if response_started:
+                            response_text.append(line)
+
+                        if prompt and prompt in line:
+                            response_started = True
+
+                    if response_text:
+                        current_text = '\n'.join(response_text)
 
                         if current_text != last_text:
                             new_chunk = current_text[len(last_text):]

main.py

@@ -1,9 +1,16 @@
 import asyncio
 import json
+import os
 import time
 import uuid
+from pathlib import Path
 from typing import Optional
 
+from dotenv import load_dotenv
+
+# 自动加载项目目录下的 .env
+load_dotenv(Path(__file__).parent / ".env")
+
 from fastapi import FastAPI, HTTPException, Header, Request
 from fastapi.middleware.cors import CORSMiddleware
 from fastapi.responses import StreamingResponse
@@ -23,7 +30,7 @@ app.add_middleware(
 )
 
 config: Config = load_config()
-manager = AccountManager(max_concurrent_per_account=config.browser.max_concurrent_per_account)
+manager = AccountManager(max_inflight=2)
 
 
 class Message(BaseModel):
@@ -56,18 +63,8 @@ async def list_models(authorization: str = Header(...)):
 
     return {
         "data": [
-            {"id": "deepseek-chat", "object": "model", "created": int(time.time()), "owned_by": "deepseek"},
-            {"id": "deepseek-reasoner", "object": "model", "created": int(time.time()), "owned_by": "deepseek"},
-            {"id": "deepseek-v4-flash", "object": "model", "created": int(time.time()), "owned_by": "deepseek"},
-            {"id": "deepseek-v4-pro", "object": "model", "created": int(time.time()), "owned_by": "deepseek"},
-            {"id": "deepseek-v4-flash-search", "object": "model", "created": int(time.time()), "owned_by": "deepseek"},
-            {"id": "deepseek-v4-pro-search", "object": "model", "created": int(time.time()), "owned_by": "deepseek"},
-            {"id": "deepseek-v4-vision", "object": "model", "created": int(time.time()), "owned_by": "deepseek"},
-            {"id": "gpt-4o", "object": "model", "created": int(time.time()), "owned_by": "openai"},
-            {"id": "gpt-4-turbo", "object": "model", "created": int(time.time()), "owned_by": "openai"},
-            {"id": "claude-3-opus", "object": "model", "created": int(time.time()), "owned_by": "anthropic"},
-            {"id": "claude-3-sonnet", "object": "model", "created": int(time.time()), "owned_by": "anthropic"},
-            {"id": "gemini-pro", "object": "model", "created": int(time.time()), "owned_by": "google"},
+            {"id": "deepseek-flash", "object": "model", "created": int(time.time()), "owned_by": "deepseek"},
+            {"id": "deepseek-pro", "object": "model", "created": int(time.time()), "owned_by": "deepseek"},
         ],
         "object": "list",
     }
@@ -78,10 +75,8 @@ async def get_model(model_id: str, authorization: str = Header(...)):
     verify_api_key(authorization)
 
     models = {
-        "deepseek-chat": {"id": "deepseek-chat", "object": "model", "created": int(time.time()), "owned_by": "deepseek"},
-        "deepseek-reasoner": {"id": "deepseek-reasoner", "object": "model", "created": int(time.time()), "owned_by": "deepseek"},
-        "deepseek-v4-flash": {"id": "deepseek-v4-flash", "object": "model", "created": int(time.time()), "owned_by": "deepseek"},
-        "deepseek-v4-pro": {"id": "deepseek-v4-pro", "object": "model", "created": int(time.time()), "owned_by": "deepseek"},
+        "deepseek-flash": {"id": "deepseek-flash", "object": "model", "created": int(time.time()), "owned_by": "deepseek"},
+        "deepseek-pro": {"id": "deepseek-pro", "object": "model", "created": int(time.time()), "owned_by": "deepseek"},
     }
 
     if model_id in models:
@@ -102,16 +97,18 @@ async def chat_completions(
 
     prompt = request.messages[-1].content
 
+    model = request.model
+
     account = await manager.acquire()
 
     try:
-        api = await manager.get_api_with_retry(account)
+        browser = await manager.get_or_create_browser_with_retry(account, headless=config.browser.headless)
 
         if request.stream:
             async def stream_with_cleanup():
                 chunk_id = f"chatcmpl-{uuid.uuid4().hex[:8]}"
                 try:
-                    async for chunk in api.send_message(prompt, model=request.model, stream=True, timeout=120):
+                    async for chunk in browser.stream_message(prompt, timeout=120, model=model):
                         data = {
                             "id": chunk_id,
                             "object": "chat.completion.chunk",
@@ -152,7 +149,7 @@ async def chat_completions(
                 media_type="text/event-stream",
             )
 
-        response_text = await api.send_message(prompt, model=request.model, stream=False, timeout=120)
+        response_text = await browser.send_message(prompt, timeout=120, model=model)
 
         await manager.release(account)
 
@@ -180,212 +177,6 @@ async def chat_completions(
         raise HTTPException(status_code=503, detail=str(e))
 
 
-@app.get("/anthropic/v1/models")
-async def anthropic_models(authorization: str = Header(...)):
-    verify_api_key(authorization)
-
-    return {
-        "data": [
-            {"id": "claude-sonnet-4-6", "object": "model", "created": int(time.time()), "owned_by": "anthropic"},
-            {"id": "claude-opus-4-6", "object": "model", "created": int(time.time()), "owned_by": "anthropic"},
-            {"id": "claude-haiku-4-5", "object": "model", "created": int(time.time()), "owned_by": "anthropic"},
-        ],
-        "object": "list",
-    }
-
-
-@app.post("/anthropic/v1/messages")
-async def anthropic_messages(request: Request, authorization: str = Header(...)):
-    verify_api_key(authorization)
-
-    body = await request.json()
-    messages = body.get("messages", [])
-    model = body.get("model", "claude-sonnet-4-6")
-    stream = body.get("stream", False)
-
-    if not messages:
-        raise HTTPException(status_code=400, detail="No messages provided")
-
-    prompt = messages[-1].get("content", "")
-
-    account = await manager.acquire()
-
-    try:
-        api = await manager.get_api_with_retry(account)
-
-        if stream:
-            async def stream_with_cleanup():
-                try:
-                    async for chunk in api.send_message(prompt, model=model, stream=True, timeout=120):
-                        data = {
-                            "type": "content_block_delta",
-                            "index": 0,
-                            "delta": {"type": "text_delta", "text": chunk},
-                        }
-                        yield f"event: content_block_delta\ndata: {json.dumps(data)}\n\n"
-                    
-                    yield f"event: message_stop\ndata: {json.dumps({'type': 'message_stop'})}\n\n"
-                except Exception as e:
-                    yield f"event: error\ndata: {json.dumps({'type': 'error', 'error': {'type': 'server_error', 'message': str(e)}})}\n\n"
-                finally:
-                    await manager.release(account)
-
-            return StreamingResponse(
-                stream_with_cleanup(),
-                media_type="text/event-stream",
-            )
-
-        response_text = await api.send_message(prompt, model=model, stream=False, timeout=120)
-
-        await manager.release(account)
-
-        return {
-            "id": f"msg_{uuid.uuid4().hex[:8]}",
-            "type": "message",
-            "role": "assistant",
-            "model": model,
-            "content": [{"type": "text", "text": response_text}],
-            "stop_reason": "end_turn",
-            "usage": {
-                "input_tokens": len(prompt.split()),
-                "output_tokens": len(response_text.split()),
-            },
-        }
-
-    except Exception as e:
-        await manager.mark_error(account)
-        raise HTTPException(status_code=503, detail=str(e))
-
-
-@app.post("/v1beta/models/{model}:generateContent")
-async def gemini_generate(model: str, request: Request, authorization: str = Header(...)):
-    verify_api_key(authorization)
-
-    body = await request.json()
-    contents = body.get("contents", [])
-
-    if not contents:
-        raise HTTPException(status_code=400, detail="No contents provided")
-
-    prompt = contents[-1].get("parts", [{}])[0].get("text", "")
-
-    account = await manager.acquire()
-
-    try:
-        api = await manager.get_api_with_retry(account)
-
-        response_text = await api.send_message(prompt, model=model, stream=False, timeout=120)
-
-        await manager.release(account)
-
-        return {
-            "candidates": [
-                {
-                    "content": {
-                        "parts": [{"text": response_text}],
-                        "role": "model",
-                    },
-                    "finishReason": "STOP",
-                }
-            ],
-            "usageMetadata": {
-                "promptTokenCount": len(prompt.split()),
-                "candidatesTokenCount": len(response_text.split()),
-                "totalTokenCount": len(prompt.split()) + len(response_text.split()),
-            },
-        }
-
-    except Exception as e:
-        await manager.mark_error(account)
-        raise HTTPException(status_code=503, detail=str(e))
-
-
-@app.post("/v1beta/models/{model}:streamGenerateContent")
-async def gemini_stream_generate(model: str, request: Request, authorization: str = Header(...)):
-    verify_api_key(authorization)
-
-    body = await request.json()
-    contents = body.get("contents", [])
-
-    if not contents:
-        raise HTTPException(status_code=400, detail="No contents provided")
-
-    prompt = contents[-1].get("parts", [{}])[0].get("text", "")
-
-    account = await manager.acquire()
-
-    try:
-        api = await manager.get_api_with_retry(account)
-
-        async def stream_with_cleanup():
-            try:
-                async for chunk in api.send_message(prompt, model=model, stream=True, timeout=120):
-                    data = {
-                        "candidates": [
-                            {
-                                "content": {
-                                    "parts": [{"text": chunk}],
-                                    "role": "model",
-                                },
-                            }
-                        ],
-                    }
-                    yield f"data: {json.dumps(data)}\n\n"
-                
-                final_data = {
-                    "candidates": [
-                        {
-                            "content": {"parts": [], "role": "model"},
-                            "finishReason": "STOP",
-                        }
-                    ],
-                    "usageMetadata": {
-                        "promptTokenCount": 0,
-                        "candidatesTokenCount": 0,
-                        "totalTokenCount": 0,
-                    },
-                }
-                yield f"data: {json.dumps(final_data)}\n\n"
-            except Exception as e:
-                yield f"data: {json.dumps({'error': {'message': str(e)}})}\n\n"
-            finally:
-                await manager.release(account)
-
-        return StreamingResponse(
-            stream_with_cleanup(),
-            media_type="text/event-stream",
-        )
-
-    except Exception as e:
-        await manager.mark_error(account)
-        raise HTTPException(status_code=503, detail=str(e))
-
-
-@app.get("/api/version")
-async def ollama_version():
-    return {"version": "0.1.0"}
-
-
-@app.get("/api/tags")
-async def ollama_tags():
-    return {
-        "models": [
-            {"name": "deepseek-chat", "model": "deepseek-chat"},
-            {"name": "deepseek-reasoner", "model": "deepseek-reasoner"},
-        ]
-    }
-
-
-@app.post("/api/show")
-async def ollama_show(request: Request):
-    body = await request.json()
-    model = body.get("model", "deepseek-chat")
-
-    return {
-        "id": model,
-        "capabilities": ["tools", "thinking"],
-    }
-
 
 @app.get("/healthz")
 async def healthz():
@@ -413,7 +204,6 @@ async def import_accounts(request: Request, admin_key: str = Header(...)):
 
     body = await request.json()
     accounts = body.get("accounts", [])
-    default_proxy = body.get("default_proxy") or config.default_proxy
 
     if not accounts:
         raise HTTPException(status_code=400, detail="No accounts provided")
@@ -423,7 +213,7 @@ async def import_accounts(request: Request, admin_key: str = Header(...)):
         email = acc.get("email")
         password = acc.get("password")
         name = acc.get("name", "")
-        proxy = acc.get("proxy") or default_proxy
+        proxy = acc.get("proxy")
 
         if email and password:
             manager.add_account(email, password, name, proxy)
@@ -442,56 +232,335 @@ async def list_accounts(admin_key: str = Header(...)):
         accounts.append({
             "email": email,
             "name": acc.name,
-            "proxy": acc.proxy,
-            "in_use_count": acc.in_use_count,
-            "max_concurrent": acc.max_concurrent,
+            "in_use": acc.in_use,
             "logged_in": acc.logged_in,
             "error_count": acc.error_count,
         })
 
-    return {
-        "accounts": accounts,
-        "total": len(accounts),
-        "max_concurrent_per_account": config.browser.max_concurrent_per_account,
-        "default_proxy": config.default_proxy,
-    }
+    return {"accounts": accounts, "total": len(accounts)}
 
 
-@app.get("/admin/config")
-async def get_config(admin_key: str = Header(...)):
-    if admin_key != config.server.admin_key:
-        raise HTTPException(status_code=401, detail="Invalid admin key")
-
-    return {
-        "server": {
-            "host": config.server.host,
-            "port": config.server.port,
-        },
-        "browser": {
-            "headless": config.browser.headless,
-            "max_concurrent_per_account": config.browser.max_concurrent_per_account,
-            "timeout": config.browser.timeout,
-        },
-        "default_proxy": config.default_proxy,
-        "account_count": len(manager.accounts),
-    }
+@app.get("/")
+async def admin_panel():
+    from fastapi.responses import HTMLResponse
+    return HTMLResponse(content=ADMIN_HTML)
 
 
 @app.on_event("startup")
 async def startup():
     for acc in config.accounts:
-        proxy = acc.proxy or config.default_proxy
         manager.add_account(
             email=acc.email,
             password=acc.password,
             name=acc.name,
-            proxy=proxy,
+            proxy=acc.proxy,
         )
 
     print(f"Loaded {len(config.accounts)} accounts")
-    print(f"Max concurrent per account: {config.browser.max_concurrent_per_account}")
-    if config.default_proxy:
-        print(f"Default proxy: {config.default_proxy}")
+
+
+ADMIN_HTML = """<!DOCTYPE html>
+<html lang="zh-CN">
+<head>
+<meta charset="UTF-8">
+<meta name="viewport" content="width=device-width,initial-scale=1">
+<title>DS2API · 控制台</title>
+<style>
+:root{--bg:#060b10;--panel:#0b1219;--border:#15202e;--text:#9bb5cf;--dim:#3d5268;--accent:#5cc8ff;--green:#3fb950;--red:#f85149;--amber:#d29922;--row-hover:rgba(92,200,255,.03)}
+*{box-sizing:border-box;margin:0;padding:0}
+body{font-family:'JetBrains Mono','Sarasa Mono SC','Cascadia Code',Consolas,monospace;background:var(--bg);color:var(--text);font-size:12.5px;line-height:1.55;-webkit-font-smoothing:antialiased;min-height:100vh}
+body::after{content:'';position:fixed;inset:0;background:radial-gradient(ellipse 60% 40% at 50% -10%,rgba(92,200,255,.025),transparent);pointer-events:none;z-index:0}
+
+/* ─�� topbar ── */
+.topbar{position:sticky;top:0;z-index:20;background:var(--panel);border-bottom:1px solid var(--border);padding:10px 20px;display:flex;align-items:center;gap:10px}
+.topbar .logo{font-weight:800;font-size:13px;color:var(--accent);letter-spacing:1.5px}
+.topbar .sep{color:var(--dim);margin:0 4px}
+.topbar .mode{font-size:10px;color:var(--dim);border:1px solid var(--border);padding:2px 8px;letter-spacing:1px}
+.topbar .stat-inline{display:flex;gap:16px;margin-left:auto;font-size:10px}
+.topbar .stat-inline span{color:var(--dim)}
+.topbar .stat-inline b{color:var(--accent);font-weight:800}
+@media(max-width:700px){.topbar .stat-inline{display:none}}
+
+/* ── main grid ── */
+.main{position:relative;z-index:1;max-width:1100px;margin:0 auto;padding:20px 16px;display:grid;grid-template-columns:1fr 1fr;gap:16px;align-items:start}
+@media(max-width:800px){.main{grid-template-columns:1fr;padding:14px 10px;gap:12px}}
+
+/* ── panel ── */
+.panel{border:1px solid var(--border);background:var(--panel)}
+.panel-head{padding:10px 14px;border-bottom:1px solid var(--border);display:flex;align-items:center;justify-content:space-between;background:rgba(92,200,255,.015)}
+.panel-head h2{font-size:11px;color:var(--accent);letter-spacing:1.5px;font-weight:800}
+.panel-head .hint{color:var(--dim);font-size:10px}
+.panel-body{padding:14px}
+
+/* ── form elements ── */
+select,textarea,input[type=text]{width:100%;background:var(--bg);border:1px solid var(--border);padding:8px 10px;color:var(--text);font-family:inherit;font-size:12px;line-height:1.5}
+select{padding:7px 10px;cursor:pointer;appearance:none;background-image:url("data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' width='8' height='5'%3E%3Cpath d='M0 0l4 5 4-5z' fill='%233d5268'/%3E%3C/svg%3E");background-repeat:no-repeat;background-position:right 10px center;padding-right:28px}
+select:focus,textarea:focus,input:focus{outline:none;border-color:var(--accent)}
+textarea{min-height:80px;resize:vertical}
+textarea::placeholder{color:var(--dim)}
+.row{display:flex;gap:10px;align-items:center;margin-bottom:10px;flex-wrap:wrap}
+
+/* ── buttons ── */
+.btn{display:inline-flex;align-items:center;gap:5px;padding:7px 14px;border:1px solid var(--border);background:transparent;color:var(--text);cursor:pointer;font-family:inherit;font-size:11px;font-weight:700;letter-spacing:.8px;white-space:nowrap;transition:all .12s}
+.btn:hover{border-color:var(--accent);color:var(--accent)}
+.btn-accent{background:var(--accent);color:var(--bg);border-color:var(--accent)}
+.btn-accent:hover{background:transparent;color:var(--accent)}
+.btn-sm{padding:5px 10px;font-size:10px}
+
+/* ── table ── */
+.tbl{width:100%;border-collapse:collapse;font-size:11px}
+.tbl thead{border-bottom:2px solid var(--border)}
+.tbl th{padding:7px 6px;text-align:left;color:var(--dim);font-weight:700;font-size:9.5px;letter-spacing:.8px;white-space:nowrap}
+.tbl td{padding:7px 6px;border-bottom:1px solid rgba(21,32,46,.6);word-break:break-all}
+.tbl tr:hover td{background:var(--row-hover)}
+@media(max-width:500px){.tbl th,.tbl td{font-size:10px;padding:6px 4px}}
+
+/* ── badge ── */
+.badge{display:inline-flex;align-items:center;gap:3px;padding:1px 7px;font-size:9.5px;font-weight:700;letter-spacing:.4px;white-space:nowrap}
+.badge::before{content:'';width:4px;height:4px}
+.badge-on{color:var(--green);border:1px solid rgba(63,185,80,.35)}.badge-on::before{background:var(--green)}
+.badge-off{color:var(--red);border:1px solid rgba(248,81,73,.3)}.badge-off::before{background:var(--red)}
+.badge-idle{color:var(--dim);border:1px solid var(--border)}.badge-idle::before{background:var(--dim)}
+
+/* ── response area ── */
+#response{background:var(--bg);border:1px solid var(--border);border-top:none;padding:12px;min-height:120px;max-height:400px;overflow-y:auto;font-size:12px;line-height:1.6;white-space:pre-wrap}
+#response:empty::after{content:'等待发送…';color:var(--dim)}
+.response-status{display:flex;justify-content:space-between;padding:6px 10px;font-size:10px;border-bottom:1px solid var(--border)}
+.response-status .ok{color:var(--green)}.response-status .err{color:var(--red)}
+
+/* ── toast ── */
+.toast{position:fixed;top:20px;right:20px;z-index:99;padding:10px 18px;font-size:11px;font-weight:700;letter-spacing:.5px;animation:slide .25s;border:1px solid}
+.toast-ok{background:rgba(63,185,80,.1);color:var(--green);border-color:rgba(63,185,80,.25)}
+.toast-err{background:rgba(248,81,73,.1);color:var(--red);border-color:rgba(248,81,73,.25)}
+@keyframes slide{from{transform:translateY(-8px);opacity:0}to{transform:translateY(0);opacity:1}}
+
+/* ── misc ── */
+.empty{color:var(--dim);padding:20px 0;text-align:center;font-size:11px}
+.hidden{display:none}
+.spacer{flex:1}
+.ellipsis{max-width:160px;overflow:hidden;text-overflow:ellipsis;display:block}
+.help{font-size:10px;color:var(--dim);margin-bottom:8px;opacity:.7}
+.imp{padding:12px;margin-top:12px}
+@media(max-width:500px){.hide-mobile{display:none}}
+</style>
+</head>
+<body>
+<div class="topbar">
+  <span class="logo">▸ DS2API</span>
+  <span class="mode">浏览器模式</span>
+  <div class="stat-inline" id="topStats">
+    <span>账号 <b>—</b></span>
+    <span>活跃 <b>—</b></span>
+    <span>可用 <b>—</b></span>
+    <span>在线 <b>—</b></span>
+    <span>排队 <b>—</b></span>
+  </div>
+</div>
+
+<div class="main">
+
+  <!-- ═══ 左栏：接口测试 ═══ -->
+  <div class="panel" style="grid-row:span 1">
+    <div class="panel-head">
+      <h2>接口测试</h2>
+      <span class="hint">/v1/chat/completions</span>
+    </div>
+    <div class="panel-body">
+      <div class="row">
+        <select id="model" style="flex:1">
+          <option value="deepseek-flash">deepseek-flash</option>
+          <option value="deepseek-pro">deepseek-pro</option>
+        </select>
+        <label style="font-size:11px;color:var(--dim);display:flex;align-items:center;gap:4px;white-space:nowrap">
+          <input type="checkbox" id="stream" checked> 流式
+        </label>
+      </div>
+      <textarea id="prompt" placeholder="输入消息…">你好，用一句话介绍你自己</textarea>
+      <div class="row" style="margin-top:10px;margin-bottom:0">
+        <button class="btn btn-accent" onclick="sendMsg()" id="sendBtn">▸ 发送</button>
+        <button class="btn btn-sm" onclick="sendMsg()" id="sendBtn2" style="display:none">▸ 发送</button>
+        <span id="reqStatus" style="font-size:10px;color:var(--dim)"></span>
+        <div class="spacer"></div>
+        <button class="btn btn-sm" onclick="document.getElementById('response').textContent=''">清空</button>
+      </div>
+      <div style="margin-top:12px;border:1px solid var(--border);border-bottom:none">
+        <div class="response-status">
+          <span id="respLabel">响应</span>
+          <span id="respTime"></span>
+        </div>
+        <div id="response"></div>
+      </div>
+    </div>
+  </div>
+
+  <!-- ═══ 右栏：账号管理 ═══ -->
+  <div class="panel">
+    <div class="panel-head">
+      <h2>账号管理</h2>
+      <button class="btn btn-sm" onclick="loadAccounts()">刷新</button>
+    </div>
+    <div class="panel-body" style="padding-bottom:8px">
+      <table class="tbl">
+        <thead><tr><th>邮箱</th><th class="hide-mobile">备注</th><th>登录</th><th>状态</th><th>禁言</th><th class="hide-mobile">错误</th></tr></thead>
+        <tbody id="tbl"><tr><td colspan="6" class="empty">加载中…</td></tr></tbody>
+      </table>
+    </div>
+  </div>
+
+  <div class="panel">
+    <div class="panel-head">
+      <h2>导入账号</h2>
+    </div>
+    <div class="panel-body">
+      <div class="help">格式：邮箱:密码 ，每行一个</div>
+      <textarea id="inp" placeholder="user@gmail.com:password&#10;user2@gmail.com:password" style="min-height:70px"></textarea>
+      <div class="row" style="margin-top:10px;margin-bottom:0">
+        <button class="btn btn-accent" onclick="doImport()">▸ 导入</button>
+        <span id="msg" style="font-size:10px;color:var(--dim)"></span>
+      </div>
+    </div>
+  </div>
+
+</div>
+
+<script>
+const H=location.origin
+const KEY='sbgptwcnmsbopenaiwdnmdcnmsbchat'
+
+function toast(m,ok){
+  const e=document.createElement('div')
+  e.className='toast toast-'+(ok?'ok':'err')
+  e.textContent=m
+  document.body.appendChild(e)
+  setTimeout(()=>e.remove(),2500)
+}
+
+async function api(p,o={}){
+  const hd={};if(o.json)hd['Content-Type']='application/json'
+  Object.assign(hd,o.headers||{})
+  const r=await fetch(H+p,{headers:hd,method:o.method||'GET',body:o.body})
+  if(!r.ok){const t=await r.text();throw new Error(t||r.status)}
+  return r.json()
+}
+
+/* ── 接口测试 ── */
+async function sendMsg(){
+  const model=document.getElementById('model').value
+  const prompt=document.getElementById('prompt').value.trim()
+  const stream=document.getElementById('stream').checked
+  const resp=document.getElementById('response')
+  const status=document.getElementById('reqStatus')
+  const timeEl=document.getElementById('respTime')
+  const btn=document.getElementById('sendBtn')
+
+  if(!prompt)return toast('请输入消息',0)
+  btn.disabled=true;btn.textContent='…'
+  resp.textContent='';timeEl.textContent=''
+
+  const t0=Date.now()
+  try{
+    const r=await fetch(H+'/v1/chat/completions',{
+      method:'POST',
+      headers:{'Content-Type':'application/json','Authorization':'Bearer '+KEY},
+      body:JSON.stringify({model,messages:[{role:'user',content:prompt}],stream})
+    })
+
+    if(stream){
+      const reader=r.body.getReader(),dec=new TextDecoder()
+      let full=''
+      while(1){
+        const{done,value}=await reader.read()
+        if(done)break
+        for(const line of dec.decode(value,{stream:true}).split('\\n')){
+          if(!line.startsWith('data: '))continue
+          const d=line.slice(6).trim()
+          if(d==='[DONE]')continue
+          try{const j=JSON.parse(d);const c=j.choices?.[0]?.delta?.content;if(c){full+=c;resp.textContent=full}}
+          catch(e){}
+        }
+      }
+      timeEl.textContent=((Date.now()-t0)/1000).toFixed(1)+'s'
+      status.textContent='流式完成';status.className='ok'
+    }else{
+      const d=await r.json()
+      resp.textContent=d.choices?.[0]?.message?.content||JSON.stringify(d,null,2)
+      timeEl.textContent=((Date.now()-t0)/1000).toFixed(1)+'s'
+      status.textContent=r.status+' OK';status.className='ok'
+    }
+  }catch(e){
+    resp.textContent='错误: '+e.message
+    status.textContent='失败';status.className='err'
+  }
+  btn.disabled=false;btn.textContent='▸ 发送'
+}
+
+/* ── 统计 & 账号 ── */
+async function loadStats(){
+  try{
+    const s=await api('/readyz')
+    document.getElementById('topStats').innerHTML=
+      `<span>账号 <b>${s.accounts.total}</b></span>
+       <span>活跃 <b>${s.accounts.in_use}</b></span>
+       <span>可用 <b>${s.accounts.available}</b></span>
+       <span>在线 <b>${s.accounts.logged_in}</b></span>
+       <span>禁言 <b style="color:var(--red)">${s.accounts.muted||0}</b></span>
+       <span>排队 <b>${s.accounts.queue_size}</b></span>`
+  }catch(e){}
+}
+async function loadAccounts(){
+  try{
+    const d=await api('/admin/accounts',{headers:{'admin-key':'admin'}})
+    let r=''
+    for(const a of d.accounts){
+      r+=`<tr>
+        <td><span class="ellipsis">${a.email}</span></td>
+        <td class="hide-mobile">${a.name||'—'}</td>
+        <td><span class="badge ${a.logged_in?'badge-on':'badge-off'}">${a.logged_in?'在线':'离线'}</span></td>
+        <td><span class="badge ${a.in_use?'badge-on':'badge-idle'}">${a.in_use?'使用中':'空闲'}</span></td>
+        <td>${a.is_muted?`<span class="badge badge-off" title="${a.muted_until||'已禁言'}">禁言</span>`:'<span class="badge badge-idle">正常</span>'}</td>
+        <td class="hide-mobile">${a.error_count>0?'<span class="badge badge-off">'+a.error_count+'</span>':'—'}</td>
+      </tr>`
+    }
+    document.getElementById('tbl').innerHTML=r||'<tr><td colspan="6" class="empty">暂无账号</td></tr>'
+  }catch(e){
+    document.getElementById('tbl').innerHTML='<tr><td colspan="6" style="color:var(--red)">'+e.message+'</td></tr>'
+  }
+}
+async function loadAll(){await loadStats();await loadAccounts()}
+
+async function doImport(){
+  const v=document.getElementById('inp').value.trim()
+  if(!v)return toast('请输入账号',0)
+  const accts=[]
+  for(const l of v.split('\\n')){
+    const t=l.trim();if(!t)continue
+    const p=t.split(':',3)
+    if(p.length>=2)accts.push({email:p[0].trim(),password:p[1],name:p[2]||''})
+  }
+  if(!accts.length)return toast('格式错误',0)
+  try{
+    const d=await api('/admin/accounts/import',{
+      method:'POST',json:true,
+      body:JSON.stringify({accounts:accts}),
+      headers:{'admin-key':'admin'}
+    })
+    document.getElementById('inp').value=''
+    document.getElementById('msg').textContent='已导入 '+d.imported+' 个'
+    toast('成功导入 '+d.imported+' 个',1)
+    loadAll()
+  }catch(e){toast(e.message,0)}
+}
+
+// 回车发送
+document.getElementById('prompt').addEventListener('keydown',e=>{
+  if(e.ctrlKey&&e.key==='Enter')sendMsg()
+})
+
+loadAll()
+setInterval(loadAll,12000)
+</script>
+</body>
+</html>"""
 
 
 def main():

test.html

@@ -1,306 +0,0 @@
-<!DOCTYPE html>
-<html lang="zh-CN">
-<head>
-    <meta charset="UTF-8">
-    <meta name="viewport" content="width=device-width, initial-scale=1.0">
-    <title>DS2API Browser 测试</title>
-    <style>
-        * { box-sizing: border-box; margin: 0; padding: 0; }
-        body { font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif; background: #f5f5f5; padding: 20px; }
-        .container { max-width: 800px; margin: 0 auto; }
-        h1 { text-align: center; margin-bottom: 20px; color: #333; }
-        .card { background: white; border-radius: 8px; padding: 20px; margin-bottom: 20px; box-shadow: 0 2px 4px rgba(0,0,0,0.1); }
-        .form-group { margin-bottom: 15px; }
-        label { display: block; margin-bottom: 5px; font-weight: 500; color: #555; }
-        input, textarea, select { width: 100%; padding: 10px; border: 1px solid #ddd; border-radius: 4px; font-size: 14px; }
-        textarea { min-height: 100px; resize: vertical; }
-        button { background: #007bff; color: white; border: none; padding: 12px 24px; border-radius: 4px; cursor: pointer; font-size: 16px; width: 100%; }
-        button:hover { background: #0056b3; }
-        button:disabled { background: #ccc; cursor: not-allowed; }
-        .response { background: #f8f9fa; border-radius: 4px; padding: 15px; margin-top: 15px; white-space: pre-wrap; word-wrap: break-word; min-height: 50px; }
-        .loading { text-align: center; color: #666; }
-        .error { color: #dc3545; }
-        .success { color: #28a745; }
-        .info { display: flex; justify-content: space-between; margin-top: 10px; font-size: 12px; color: #888; }
-        .checkbox-group { display: flex; align-items: center; gap: 10px; }
-        .checkbox-group input { width: auto; }
-    </style>
-</head>
-<body>
-    <div class="container">
-        <h1>🤖 DS2API Browser 测试</h1>
-        
-        <div class="card">
-            <div class="form-group">
-                <label>API 地址</label>
-                <input type="text" id="apiUrl" value="http://localhost:5002">
-            </div>
-            <div class="form-group">
-                <label>API Key</label>
-                <input type="text" id="apiKey" value="sk-test123456">
-            </div>
-            <div class="form-group">
-                <label>模型</label>
-                <select id="model">
-                    <option value="deepseek-v4-flash">deepseek-v4-flash (默认)</option>
-                    <option value="deepseek-v4-pro">deepseek-v4-pro (专家)</option>
-                    <option value="deepseek-v4-flash-search">deepseek-v4-flash-search</option>
-                    <option value="deepseek-v4-pro-search">deepseek-v4-pro-search</option>
-                </select>
-            </div>
-            <div class="form-group">
-                <div class="checkbox-group">
-                    <input type="checkbox" id="stream" checked>
-                    <label for="stream">流式响应</label>
-                </div>
-            </div>
-            <div class="form-group">
-                <label>消息</label>
-                <textarea id="message" placeholder="输入你的消息...">你好，请介绍一下你自己</textarea>
-            </div>
-            <button id="sendBtn" onclick="sendMessage()">发送消息</button>
-        </div>
-        
-        <div class="card">
-            <label>响应</label>
-            <div id="response" class="response">等待发送...</div>
-            <div class="info">
-                <span id="status"></span>
-                <span id="time"></span>
-            </div>
-        </div>
-        
-        <div class="card">
-            <label>账号管理</label>
-            <div class="form-group" style="margin-top: 10px;">
-                <label>导入账号 (格式: email:password:代理地址，每行一个)</label>
-                <textarea id="accountsInput" rows="4" placeholder="user1@gmail.com:password1&#10;user2@gmail.com:password2:socks5://127.0.0.1:1080"></textarea>
-            </div>
-            <div class="form-group">
-                <label>默认代理 (可选，格式: socks5://127.0.0.1:1080)</label>
-                <input type="text" id="defaultProxy" placeholder="socks5://127.0.0.1:1080">
-            </div>
-            <div style="display: flex; gap: 10px;">
-                <button onclick="importAccounts()" style="flex: 1;">导入账号</button>
-                <button onclick="loadAccounts()" style="flex: 1; background: #6c757d;">刷新账号列表</button>
-            </div>
-            <div id="accountsList" class="response" style="margin-top: 10px; max-height: 200px; overflow-y: auto;">点击"刷新账号列表"查看...</div>
-        </div>
-    </div>
-
-    <script>
-        async function sendMessage() {
-            const apiUrl = document.getElementById('apiUrl').value;
-            const apiKey = document.getElementById('apiKey').value;
-            const model = document.getElementById('model').value;
-            const message = document.getElementById('message').value;
-            const isStream = document.getElementById('stream').checked;
-            const responseDiv = document.getElementById('response');
-            const statusSpan = document.getElementById('status');
-            const timeSpan = document.getElementById('time');
-            const sendBtn = document.getElementById('sendBtn');
-            
-            if (!message.trim()) {
-                responseDiv.textContent = '请输入消息';
-                responseDiv.className = 'response error';
-                return;
-            }
-            
-            sendBtn.disabled = true;
-            sendBtn.textContent = '发送中...';
-            responseDiv.textContent = '正在等待响应...';
-            responseDiv.className = 'response loading';
-            statusSpan.textContent = '';
-            timeSpan.textContent = '';
-            
-            const startTime = Date.now();
-            
-            try {
-                const response = await fetch(`${apiUrl}/v1/chat/completions`, {
-                    method: 'POST',
-                    headers: {
-                        'Content-Type': 'application/json',
-                        'Authorization': `Bearer ${apiKey}`
-                    },
-                    body: JSON.stringify({
-                        model: model,
-                        messages: [{ role: 'user', content: message }],
-                        stream: isStream
-                    })
-                });
-                
-                if (isStream) {
-                    const reader = response.body.getReader();
-                    const decoder = new TextDecoder();
-                    let fullContent = '';
-                    
-                    while (true) {
-                        const { done, value } = await reader.read();
-                        if (done) break;
-                        
-                        const chunk = decoder.decode(value, { stream: true });
-                        const lines = chunk.split('\n');
-                        
-                        for (const line of lines) {
-                            if (line.startsWith('data: ')) {
-                                const data = line.slice(6).trim();
-                                if (data === '[DONE]') continue;
-                                
-                                try {
-                                    const json = JSON.parse(data);
-                                    const content = json.choices?.[0]?.delta?.content;
-                                    if (content) {
-                                        fullContent += content;
-                                        responseDiv.textContent = fullContent;
-                                        responseDiv.className = 'response success';
-                                    }
-                                } catch (e) {
-                                    // Skip invalid JSON
-                                }
-                            }
-                        }
-                    }
-                    
-                    const elapsed = ((Date.now() - startTime) / 1000).toFixed(1);
-                    statusSpan.textContent = `状态: 流式完成`;
-                    timeSpan.textContent = `耗时: ${elapsed}s`;
-                } else {
-                    const data = await response.json();
-                    const elapsed = ((Date.now() - startTime) / 1000).toFixed(1);
-                    
-                    if (response.ok) {
-                        const content = data.choices?.[0]?.message?.content || '无响应内容';
-                        responseDiv.textContent = content;
-                        responseDiv.className = 'response success';
-                        statusSpan.textContent = `状态: ${response.status || 200} OK`;
-                    } else {
-                        responseDiv.textContent = `错误: ${data.detail || JSON.stringify(data)}`;
-                        responseDiv.className = 'response error';
-                        statusSpan.textContent = `状态: ${response.status || '错误'}`;
-                    }
-                    
-                    timeSpan.textContent = `耗时: ${elapsed}s`;
-                }
-                
-            } catch (error) {
-                responseDiv.textContent = `请求失败: ${error.message}`;
-                responseDiv.className = 'response error';
-                statusSpan.textContent = '错误';
-            } finally {
-                sendBtn.disabled = false;
-                sendBtn.textContent = '发送消息';
-            }
-        }
-        
-        document.getElementById('message').addEventListener('keydown', function(e) {
-            if (e.ctrlKey && e.key === 'Enter') {
-                sendMessage();
-            }
-        });
-        
-        async function importAccounts() {
-            const apiUrl = document.getElementById('apiUrl').value;
-            const apiKey = document.getElementById('apiKey').value;
-            const accountsText = document.getElementById('accountsInput').value.trim();
-            const defaultProxy = document.getElementById('defaultProxy').value.trim();
-            const accountsList = document.getElementById('accountsList');
-            
-            if (!accountsText) {
-                accountsList.textContent = '请输入账号信息';
-                accountsList.className = 'response error';
-                return;
-            }
-            
-            const lines = accountsText.split('\n').filter(line => line.trim());
-            const accounts = [];
-            
-            for (const line of lines) {
-                const parts = line.split(':');
-                if (parts.length >= 2) {
-                    accounts.push({ 
-                        email: parts[0].trim(), 
-                        password: parts[1].trim(),
-                        proxy: parts[2] ? parts[2].trim() : null
-                    });
-                }
-            }
-            
-            if (accounts.length === 0) {
-                accountsList.textContent = '格式错误，请使用 email:password 或 email:password:proxy 格式';
-                accountsList.className = 'response error';
-                return;
-            }
-            
-            accountsList.textContent = '导入中...';
-            accountsList.className = 'response loading';
-            
-            try {
-                const body = { accounts };
-                if (defaultProxy) {
-                    body.default_proxy = defaultProxy;
-                }
-                
-                const response = await fetch(`${apiUrl}/admin/accounts/import`, {
-                    method: 'POST',
-                    headers: {
-                        'Content-Type': 'application/json',
-                        'Authorization': `Bearer ${apiKey}`,
-                        'admin-key': 'admin'
-                    },
-                    body: JSON.stringify(body)
-                });
-                
-                const data = await response.json();
-                
-                if (response.ok) {
-                    accountsList.textContent = JSON.stringify(data, null, 2);
-                    accountsList.className = 'response success';
-                    document.getElementById('accountsInput').value = '';
-                } else {
-                    accountsList.textContent = `错误: ${data.detail || JSON.stringify(data)}`;
-                    accountsList.className = 'response error';
-                }
-            } catch (error) {
-                accountsList.textContent = `请求失败: ${error.message}`;
-                accountsList.className = 'response error';
-            }
-        }
-        
-        async function loadAccounts() {
-            const apiUrl = document.getElementById('apiUrl').value;
-            const apiKey = document.getElementById('apiKey').value;
-            const accountsList = document.getElementById('accountsList');
-            
-            accountsList.textContent = '加载中...';
-            accountsList.className = 'response loading';
-            
-            try {
-                const response = await fetch(`${apiUrl}/admin/accounts`, {
-                    method: 'GET',
-                    headers: {
-                        'Authorization': `Bearer ${apiKey}`,
-                        'admin-key': 'admin'
-                    }
-                });
-                
-                const data = await response.json();
-                
-                if (response.ok) {
-                    let html = `账号数量: ${data.total}\n\n`;
-                    for (const acc of data.accounts) {
-                        html += `邮箱: ${acc.email}\n状态: ${acc.status}\n使用次数: ${acc.usage_count}\n\n`;
-                    }
-                    accountsList.textContent = html;
-                    accountsList.className = 'response success';
-                } else {
-                    accountsList.textContent = `错误: ${data.detail || JSON.stringify(data)}`;
-                    accountsList.className = 'response error';
-                }
-            } catch (error) {
-                accountsList.textContent = `请求失败: ${error.message}`;
-                accountsList.className = 'response error';
-            }
-        }
-    </script>
-</body>
-</html>