feat: DS2API Browser - CloakBrowser-based DeepSeek API proxy

- OpenAI/Claude/Gemini/Ollama compatible API endpoints
- Streaming support (SSE format)
- Multi-account pool with acquire/release
- Web-based account import UI
- Browser automation with CloakBrowser (anti-detection)
- Persistent browser profiles
- Human behavior simulation

.gitignore

@@ -0,0 +1,17 @@
+# 浏览器 profile 数据
+test-profile*/
+profiles/
+*.log
+
+# Python
+__pycache__/
+*.py[cod]
+venv/
+.env
+
+# 账号数据（敏感信息）
+accounts.json
+
+# 系统文件
+.DS_Store
+Thumbs.db

README.md

@@ -0,0 +1,138 @@
+# DS2API Browser
+
+基于 CloakBrowser/Playwright 的 DeepSeek API 代理服务。
+
+## 特性
+
+- **浏览器自动化** - 使用真实浏览器访问 DeepSeek，无法被检测
+- **OpenAI 兼容 API** - 支持 `/v1/chat/completions` 接口
+- **流式响应** - 支持 SSE 流式输出
+- **账号池管理** - 支持多账号轮询
+- **人类行为模拟** - 模拟真实用户操作
+
+## 安装
+
+```bash
+cd /home/huanx/code/ds2api-browser
+python -m venv venv
+source venv/bin/activate
+pip install -r requirements.txt
+
+# 安装 Playwright 浏览器（如果不用 CloakBrowser）
+playwright install chromium
+```
+
+## 使用
+
+### 方式 1: 环境变量配置
+
+```bash
+export DS2API_ACCOUNTS="email1@gmail.com:password1;email2@gmail.com:password2"
+export DS2API_KEYS="sk-key1,sk-key2"
+export DS2API_ADMIN_KEY="your-admin-key"
+export DS2API_PORT="5001"
+export DS2API_HEADLESS="true"
+export DS2API_HUMANIZE="true"
+
+python main.py
+```
+
+### 方式 2: 直接运行
+
+```bash
+python start.py
+```
+
+### 方式 3: 后台运行
+
+```bash
+nohup python main.py > /tmp/ds2api-browser.log 2>&1 &
+```
+
+## API 使用
+
+### 聊天补全
+
+```bash
+curl http://localhost:5001/v1/chat/completions \
+  -H "Authorization: Bearer sk-test123456" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "model": "deepseek-chat",
+    "messages": [{"role": "user", "content": "Hello!"}]
+  }'
+```
+
+### 流式响应
+
+```bash
+curl http://localhost:5001/v1/chat/completions \
+  -H "Authorization: Bearer sk-test123456" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "model": "deepseek-chat",
+    "messages": [{"role": "user", "content": "Hello!"}],
+    "stream": true
+  }'
+```
+
+### Python OpenAI SDK
+
+```python
+from openai import OpenAI
+
+client = OpenAI(
+    base_url="http://localhost:5001/v1",
+    api_key="sk-test123456"
+)
+
+response = client.chat.completions.create(
+    model="deepseek-chat",
+    messages=[{"role": "user", "content": "Hello!"}]
+)
+print(response.choices[0].message.content)
+```
+
+## 健康检查
+
+```bash
+# 健康检查
+curl http://localhost:5001/healthz
+
+# 就绪检查
+curl http://localhost:5001/readyz
+
+# 管理统计
+curl http://localhost:5001/admin/stats -H "admin-key: admin"
+```
+
+## 与原版 DS2API 的区别
+
+| 特性 | 原版 DS2API | DS2API Browser |
+|------|-------------|----------------|
+| 实现方式 | HTTP 客户端 | 浏览器自动化 |
+| 指纹检测 | 容易被检测 | 无法被检测 |
+| 账号封禁 | 高风险 | 低风险 |
+| 性能 | 快 | 较慢 |
+| 资源占用 | 低 | 高 |
+
+## 注意事项
+
+1. **首次运行** - Playwright/CloakBrowser 会下载浏览器二进制文件（~200MB）
+2. **资源占用** - 每个浏览器实例占用约 200-500MB 内存
+3. **性能** - 浏览器自动化比直接 HTTP 慢，但更安全
+4. **账号安全** - 建议使用小号测试，不要用主账号
+
+## 文件结构
+
+```
+ds2api-browser/
+├── main.py              # FastAPI 服务器
+├── deepseek_browser.py  # 浏览器自动化核心
+├── account_manager.py   # 账号池管理
+├── config.py            # 配置管理
+├── start.py             # 快速启动脚本
+├── run.py               # 运行入口
+├── requirements.txt     # 依赖列表
+└── README.md            # 本文档
+```

account_manager.py

@@ -0,0 +1,121 @@
+import asyncio
+from collections import deque
+from dataclasses import dataclass, field
+from typing import Dict, Optional
+
+from deepseek_browser import DeepSeekBrowser
+
+
+@dataclass
+class Account:
+    email: str
+    password: str
+    name: str = ""
+    proxy: Optional[str] = None
+    browser: Optional[DeepSeekBrowser] = field(default=None, repr=False)
+    in_use: bool = False
+    error_count: int = 0
+    logged_in: bool = False
+
+
+class AccountManager:
+    def __init__(self, max_inflight: int = 1):
+        self.accounts: Dict[str, Account] = {}
+        self.queue: deque = deque()
+        self.max_inflight = max_inflight
+        self._lock = asyncio.Lock()
+
+    def add_account(self, email: str, password: str, name: str = "", proxy: Optional[str] = None):
+        self.accounts[email] = Account(
+            email=email,
+            password=password,
+            name=name,
+            proxy=proxy,
+        )
+
+    async def acquire(self) -> Account:
+        async with self._lock:
+            for account in self.accounts.values():
+                if not account.in_use and account.error_count < 3:
+                    account.in_use = True
+                    return account
+
+        return await self._wait_for_account()
+
+    async def _wait_for_account(self) -> Account:
+        event = asyncio.Event()
+        async with self._lock:
+            self.queue.append(event)
+
+        await event.wait()
+
+        async with self._lock:
+            for account in self.accounts.values():
+                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 = False
+            if self.queue:
+                event = self.queue.popleft()
+                event.set()
+
+    async def mark_error(self, account: Account):
+        async with self._lock:
+            account.error_count += 1
+            account.in_use = False
+            if self.queue:
+                event = self.queue.popleft()
+                event.set()
+
+    async def get_or_create_browser(self, account: Account, headless: bool = True) -> DeepSeekBrowser:
+        try:
+            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.browser.start()
+                account.logged_in = True
+            return account.browser
+        except Exception as e:
+            print(f"Error creating browser: {e}")
+            await self.close_browser(account)
+            raise
+
+    async def get_or_create_browser_with_retry(self, account: Account, headless: bool = True) -> DeepSeekBrowser:
+        try:
+            return await self.get_or_create_browser(account, headless)
+        except Exception:
+            await self.close_browser(account)
+            return await self.get_or_create_browser(account, headless)
+
+    async def close_browser(self, account: Account):
+        if account.browser:
+            try:
+                await account.browser.close()
+            except:
+                pass
+            account.browser = None
+            account.logged_in = False
+
+    def get_stats(self) -> Dict:
+        total = len(self.accounts)
+        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)
+        return {
+            "total": total,
+            "in_use": in_use,
+            "available": available,
+            "logged_in": logged_in,
+            "queue_size": len(self.queue),
+        }

config.py

@@ -0,0 +1,70 @@
+import os
+from dataclasses import dataclass, field
+from typing import List, Optional
+
+
+@dataclass
+class AccountConfig:
+    email: str
+    password: str
+    name: str = ""
+    proxy: Optional[str] = None
+
+
+@dataclass
+class ServerConfig:
+    host: str = "0.0.0.0"
+    port: int = 5001
+    admin_key: str = "admin"
+
+
+@dataclass
+class BrowserConfig:
+    headless: bool = True
+    humanize: bool = True
+    timeout: int = 60000
+    viewport_width: int = 1920
+    viewport_height: int = 1080
+
+
+@dataclass
+class Config:
+    server: ServerConfig = field(default_factory=ServerConfig)
+    browser: BrowserConfig = field(default_factory=BrowserConfig)
+    accounts: List[AccountConfig] = field(default_factory=list)
+    api_keys: List[str] = field(default_factory=lambda: ["sk-default"])
+
+    @classmethod
+    def from_env(cls) -> "Config":
+        accounts = []
+        
+        account_str = os.getenv("DS2API_ACCOUNTS", "")
+        if account_str:
+            for acc in account_str.split(";"):
+                parts = acc.split(":")
+                if len(parts) >= 2:
+                    accounts.append(AccountConfig(
+                        email=parts[0],
+                        password=parts[1],
+                        name=parts[2] if len(parts) > 2 else "",
+                        proxy=parts[3] if len(parts) > 3 else None,
+                    ))
+
+        return cls(
+            server=ServerConfig(
+                host=os.getenv("DS2API_HOST", "0.0.0.0"),
+                port=int(os.getenv("DS2API_PORT", "5001")),
+                admin_key=os.getenv("DS2API_ADMIN_KEY", "admin"),
+            ),
+            browser=BrowserConfig(
+                headless=os.getenv("DS2API_HEADLESS", "true").lower() == "true",
+                humanize=os.getenv("DS2API_HUMANIZE", "true").lower() == "true",
+                timeout=int(os.getenv("DS2API_TIMEOUT", "60000")),
+            ),
+            accounts=accounts,
+            api_keys=os.getenv("DS2API_KEYS", "sk-default").split(","),
+        )
+
+
+def load_config() -> Config:
+    return Config.from_env()

deepseek_browser.py

@@ -0,0 +1,307 @@
+import asyncio
+import random
+import time
+from pathlib import Path
+from typing import AsyncGenerator, Optional
+
+from cloakbrowser import launch_persistent_context_async
+
+
+class DeepSeekBrowser:
+    DEEPSEEK_URL = "https://chat.deepseek.com"
+
+    def __init__(
+        self,
+        email: str,
+        password: str,
+        profile_dir: str = "./profiles",
+        headless: bool = True,
+        humanize: bool = True,
+        proxy: Optional[str] = None,
+    ):
+        self.email = email
+        self.password = password
+        self.profile_dir = Path(profile_dir) / email.replace("@", "_at_").replace("+", "_plus_")
+        self.headless = headless
+        self.humanize = humanize
+        self.proxy = proxy
+        self.context = None
+        self.page = None
+        self._logged_in = False
+        self._ready = False
+
+    async def start(self):
+        self.profile_dir.mkdir(parents=True, exist_ok=True)
+
+        self.context = await launch_persistent_context_async(
+            user_data_dir=str(self.profile_dir),
+            headless=self.headless,
+            humanize=self.humanize,
+            proxy=self.proxy,
+            viewport={"width": 1920, "height": 1080},
+            locale="zh-CN",
+        )
+
+        self.page = await self.context.new_page()
+        await self.page.goto(self.DEEPSEEK_URL, timeout=60000)
+        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()
+
+    async def _auto_login(self):
+        print(f"Logging in as {self.email}...")
+
+        try:
+            email_input = self.page.locator('input[placeholder*="邮箱"], input[placeholder*="手机"], 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:
+            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
+
+        try:
+            await self.page.wait_for_selector('textarea', timeout=30000)
+            self._logged_in = True
+            self._ready = True
+            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
+        await asyncio.sleep(delay)
+
+    async def new_chat(self):
+        try:
+            await self.page.goto(self.DEEPSEEK_URL, timeout=30000)
+            await asyncio.sleep(2)
+            await self.page.wait_for_selector('textarea', timeout=15000)
+        except Exception as e:
+            print(f"New chat error: {e}")
+            raise
+
+    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)
+
+                    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
+
+    async def switch_model(self, model: str):
+        try:
+            if 'reasoner' in model or 'thinking' in model:
+                thinking_btn = self.page.locator('button:has-text("深度思考"), div:has-text("深度思考")').first
+                if await thinking_btn.count() > 0:
+                    await thinking_btn.click()
+                    await asyncio.sleep(0.5)
+
+            if 'search' in model:
+                search_btn = self.page.locator('button:has-text("智能搜索"), div:has-text("智能搜索")').first
+                if await search_btn.count() > 0:
+                    await search_btn.click()
+                    await asyncio.sleep(0.5)
+        except Exception:
+            pass
+
+    async def send_message(self, prompt: str, timeout: int = 120, model: str = "deepseek-chat") -> str:
+        try:
+            await self.new_chat()
+            await self.switch_model(model)
+
+            input_field = self.page.locator('textarea').first
+            await input_field.wait_for(state="visible", timeout=15000)
+
+            await self._human_delay(500, 2000)
+
+            await input_field.clear()
+            await input_field.type(prompt, delay=random.randint(30, 80))
+
+            await self._human_delay(200, 800)
+
+            await input_field.press('Enter')
+
+            response = await self._wait_for_response(timeout, prompt)
+
+            await self.delete_chat()
+
+            return response
+        except Exception as e:
+            print(f"Send message error: {e}")
+            raise
+
+    async def _wait_for_response(self, timeout: int, prompt: str = "") -> str:
+        deadline = time.time() + timeout
+
+        await asyncio.sleep(3)
+
+        last_text = ""
+        stable_count = 0
+
+        skip_phrases = ['深度思考', '智能搜索', '快速模式', '专家模式', '内容由 AI 生成', '开启新对话', '暂无历史对话', '今天', 'huan********dja@gmail.com']
+
+        while time.time() < deadline:
+            try:
+                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
+
+                    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
+                        stable_count = 0
+                    else:
+                        stable_count += 1
+
+                    if stable_count >= 3:
+                        return current_text.strip()
+
+            except Exception:
+                pass
+
+            await asyncio.sleep(0.5)
+
+        if last_text:
+            return last_text.strip()
+
+        raise TimeoutError("No response received")
+
+    async def stream_message(self, prompt: str, timeout: int = 120, model: str = "deepseek-chat") -> AsyncGenerator[str, None]:
+        try:
+            await self.new_chat()
+            await self.switch_model(model)
+
+            input_field = self.page.locator('textarea').first
+            await input_field.wait_for(state="visible", timeout=15000)
+
+            await self._human_delay(500, 2000)
+
+            await input_field.clear()
+            await input_field.type(prompt, delay=random.randint(30, 80))
+
+            await self._human_delay(200, 800)
+
+            await input_field.press('Enter')
+
+            deadline = time.time() + timeout
+            last_text = ""
+            stable_count = 0
+
+            skip_phrases = ['深度思考', '智能搜索', '快速模式', '专家模式', '内容由 AI 生成', '开启新对话', '暂无历史对话', '今天', 'huan********dja@gmail.com']
+
+            await asyncio.sleep(3)
+
+            while time.time() < deadline:
+                try:
+                    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
+
+                        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):]
+                            if new_chunk:
+                                yield new_chunk
+                            last_text = current_text
+                            stable_count = 0
+                        else:
+                            stable_count += 1
+
+                        if stable_count >= 3:
+                            return
+
+                except Exception:
+                    pass
+
+                await asyncio.sleep(0.3)
+        except Exception as e:
+            print(f"Stream message error: {e}")
+            raise
+
+    async def close(self):
+        if self.context:
+            await self.context.close()

main.py

@@ -0,0 +1,476 @@
+import asyncio
+import json
+import time
+import uuid
+from typing import Optional
+
+from fastapi import FastAPI, HTTPException, Header, Request
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import StreamingResponse
+from pydantic import BaseModel
+
+from account_manager import AccountManager
+from config import Config, load_config
+
+app = FastAPI(title="DS2API Browser")
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+config: Config = load_config()
+manager = AccountManager(max_inflight=1)
+
+
+class Message(BaseModel):
+    role: str
+    content: str
+
+
+class ChatCompletionRequest(BaseModel):
+    model: str
+    messages: list[Message]
+    stream: bool = False
+    temperature: Optional[float] = None
+    max_tokens: Optional[int] = None
+
+
+def verify_api_key(authorization: Optional[str] = Header(None)) -> str:
+    if not authorization:
+        raise HTTPException(status_code=401, detail="Missing API key")
+
+    token = authorization.replace("Bearer ", "").strip()
+    if token not in config.api_keys:
+        raise HTTPException(status_code=401, detail="Invalid API key")
+
+    return token
+
+
+@app.get("/v1/models")
+async def list_models(authorization: str = Header(...)):
+    verify_api_key(authorization)
+
+    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"},
+        ],
+        "object": "list",
+    }
+
+
+@app.get("/v1/models/{model_id}")
+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"},
+    }
+
+    if model_id in models:
+        return models[model_id]
+
+    raise HTTPException(status_code=404, detail="Model not found")
+
+
+@app.post("/v1/chat/completions")
+async def chat_completions(
+    request: ChatCompletionRequest,
+    authorization: str = Header(...),
+):
+    verify_api_key(authorization)
+
+    if not request.messages:
+        raise HTTPException(status_code=400, detail="No messages provided")
+
+    prompt = request.messages[-1].content
+
+    account = await manager.acquire()
+
+    try:
+        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 browser.stream_message(prompt, timeout=120, model=request.model):
+                        data = {
+                            "id": chunk_id,
+                            "object": "chat.completion.chunk",
+                            "created": int(time.time()),
+                            "model": request.model,
+                            "choices": [
+                                {
+                                    "index": 0,
+                                    "delta": {"content": chunk},
+                                    "finish_reason": None,
+                                }
+                            ],
+                        }
+                        yield f"data: {json.dumps(data)}\n\n"
+                    
+                    final_data = {
+                        "id": chunk_id,
+                        "object": "chat.completion.chunk",
+                        "created": int(time.time()),
+                        "model": request.model,
+                        "choices": [
+                            {
+                                "index": 0,
+                                "delta": {},
+                                "finish_reason": "stop",
+                            }
+                        ],
+                    }
+                    yield f"data: {json.dumps(final_data)}\n\n"
+                    yield "data: [DONE]\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",
+            )
+
+        response_text = await browser.send_message(prompt, timeout=120, model=request.model)
+
+        await manager.release(account)
+
+        return {
+            "id": f"chatcmpl-{uuid.uuid4().hex[:8]}",
+            "object": "chat.completion",
+            "created": int(time.time()),
+            "model": request.model,
+            "choices": [
+                {
+                    "index": 0,
+                    "message": {"role": "assistant", "content": response_text},
+                    "finish_reason": "stop",
+                }
+            ],
+            "usage": {
+                "prompt_tokens": len(prompt.split()),
+                "completion_tokens": len(response_text.split()),
+                "total_tokens": 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.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:
+        browser = await manager.get_or_create_browser_with_retry(account, headless=config.browser.headless)
+
+        if stream:
+            async def stream_with_cleanup():
+                try:
+                    async for chunk in browser.stream_message(prompt, timeout=120, model=model):
+                        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 browser.send_message(prompt, timeout=120, model=model)
+
+        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:
+        browser = await manager.get_or_create_browser_with_retry(account, headless=config.browser.headless)
+
+        response_text = await browser.send_message(prompt, timeout=120, model=model)
+
+        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:
+        browser = await manager.get_or_create_browser_with_retry(account, headless=config.browser.headless)
+
+        async def stream_with_cleanup():
+            try:
+                async for chunk in browser.stream_message(prompt, timeout=120, model=model):
+                    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():
+    return {"status": "ok"}
+
+
+@app.get("/readyz")
+async def readyz():
+    stats = manager.get_stats()
+    return {"status": "ok", "accounts": stats}
+
+
+@app.get("/admin/stats")
+async def admin_stats(admin_key: str = Header(...)):
+    if admin_key != config.server.admin_key:
+        raise HTTPException(status_code=401, detail="Invalid admin key")
+
+    return manager.get_stats()
+
+
+@app.post("/admin/accounts/import")
+async def import_accounts(request: Request, admin_key: str = Header(...)):
+    if admin_key != config.server.admin_key:
+        raise HTTPException(status_code=401, detail="Invalid admin key")
+
+    body = await request.json()
+    accounts = body.get("accounts", [])
+
+    if not accounts:
+        raise HTTPException(status_code=400, detail="No accounts provided")
+
+    imported = 0
+    for acc in accounts:
+        email = acc.get("email")
+        password = acc.get("password")
+        name = acc.get("name", "")
+        proxy = acc.get("proxy")
+
+        if email and password:
+            manager.add_account(email, password, name, proxy)
+            imported += 1
+
+    return {"success": True, "imported": imported, "total": len(manager.accounts)}
+
+
+@app.get("/admin/accounts")
+async def list_accounts(admin_key: str = Header(...)):
+    if admin_key != config.server.admin_key:
+        raise HTTPException(status_code=401, detail="Invalid admin key")
+
+    accounts = []
+    for email, acc in manager.accounts.items():
+        accounts.append({
+            "email": email,
+            "name": acc.name,
+            "in_use": acc.in_use,
+            "logged_in": acc.logged_in,
+            "error_count": acc.error_count,
+        })
+
+    return {"accounts": accounts, "total": len(accounts)}
+
+
+@app.on_event("startup")
+async def startup():
+    for acc in config.accounts:
+        manager.add_account(
+            email=acc.email,
+            password=acc.password,
+            name=acc.name,
+            proxy=acc.proxy,
+        )
+
+    print(f"Loaded {len(config.accounts)} accounts")
+
+
+def main():
+    import uvicorn
+
+    uvicorn.run(
+        app,
+        host=config.server.host,
+        port=config.server.port,
+    )
+
+
+if __name__ == "__main__":
+    main()

requirements.txt

@@ -0,0 +1,5 @@
+cloakbrowser>=0.3.0
+fastapi>=0.100.0
+uvicorn>=0.23.0
+pydantic>=2.0.0
+python-dotenv>=1.0.0

run.py

@@ -0,0 +1,10 @@
+#!/usr/bin/env python3
+import os
+import sys
+
+sys.path.insert(0, os.path.dirname(__file__))
+
+from main import main
+
+if __name__ == "__main__":
+    main()

start.py

@@ -0,0 +1,19 @@
+#!/usr/bin/env python3
+"""Quick test script for DS2API Browser with multiple accounts."""
+import os
+import sys
+
+sys.path.insert(0, os.path.dirname(__file__))
+
+# 多账号配置，用分号分隔
+# 格式: email:password:name:proxy
+os.environ["DS2API_ACCOUNTS"] = "huanxiangnb+dja@gmail.com:m1234567:账号1;huanxiangnb+321fffww@gmail.com:m1234567:账号2"
+os.environ["DS2API_KEYS"] = "sk-test123456"
+os.environ["DS2API_ADMIN_KEY"] = "admin"
+os.environ["DS2API_PORT"] = "5002"
+os.environ["DS2API_HEADLESS"] = "true"
+
+from main import main
+
+if __name__ == "__main__":
+    main()

test.html

@@ -0,0 +1,292 @@
+<!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"></textarea>
+            </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 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 [email, password] = line.split(':');
+                if (email && password) {
+                    accounts.push({ email: email.trim(), password: password.trim() });
+                }
+            }
+            
+            if (accounts.length === 0) {
+                accountsList.textContent = '格式错误，请使用 email:password 格式';
+                accountsList.className = 'response error';
+                return;
+            }
+            
+            accountsList.textContent = '导入中...';
+            accountsList.className = 'response loading';
+            
+            try {
+                const response = await fetch(`${apiUrl}/admin/accounts/import`, {
+                    method: 'POST',
+                    headers: {
+                        'Content-Type': 'application/json',
+                        'Authorization': `Bearer ${apiKey}`,
+                        'admin-key': 'admin'
+                    },
+                    body: JSON.stringify({ accounts })
+                });
+                
+                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>