fix: login timeout, target crash, screenshot viewer, prelogin speed

deepseek_browser.py

@@ -1,5 +1,6 @@
 import asyncio
 import logging
+import os
 import random
 import time
 from pathlib import Path
@@ -9,19 +10,14 @@ from cloakbrowser import launch_persistent_context_async
 
 logger = logging.getLogger(__name__)
 
+SCREENSHOT_DIR = Path(__file__).parent / "static" / "screenshots"
+
 
 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,
-    ):
+    def __init__(self, email, password, profile_dir="./profiles",
+                 headless=True, humanize=True, proxy=None):
         self.email = email
         self.password = password
         self.profile_dir = Path(profile_dir) / email.replace("@", "_at_").replace("+", "_plus_")
@@ -33,69 +29,89 @@ class DeepSeekBrowser:
         self._logged_in = False
         self._ready = False
 
+    def _safe_email(self):
+        return self.email.replace("@", "_at_").replace("+", "_plus_")
+
+    async def _save_screenshot(self, tag):
+        try:
+            SCREENSHOT_DIR.mkdir(parents=True, exist_ok=True)
+            path = SCREENSHOT_DIR / f"{tag}_{self._safe_email()}.png"
+            await self.page.screenshot(path=str(path))
+            logger.error("Screenshot saved to %s", path)
+        except Exception as e:
+            logger.debug("Screenshot failed: %s", e)
+
+    async def _human_delay(self, min_ms=5, max_ms=30):
+        await asyncio.sleep(random.uniform(min_ms, max_ms) / 1000)
+
     async def start(self):
         self.profile_dir.mkdir(parents=True, exist_ok=True)
-
-        # 极致的省内存参数
         args = [
-            "--disable-gpu",
-            "--disable-dev-shm-usage",
-            "--disable-extensions",
-            "--disable-background-networking",
-            "--disable-default-apps",
-            "--disable-sync",
-            "--mute-audio",
-            "--no-sandbox",
-            "--js-flags=--max-old-space-size=128",  # 限制 V8 引擎内存
-            "--renderer-process-limit=1",           # 限制渲染进程
+            "--disable-gpu", "--disable-dev-shm-usage", "--disable-extensions",
+            "--disable-background-networking", "--disable-default-apps",
+            "--disable-sync", "--mute-audio", "--no-sandbox",
+            "--js-flags=--max-old-space-size=128", "--renderer-process-limit=1",
         ]
-
         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": 1280, "height": 720}, # 减小渲染面积，降低合成内存
-            locale="zh-CN",
-            args=args,
+            user_data_dir=str(self.profile_dir), headless=self.headless,
+            humanize=self.humanize, proxy=self.proxy,
+            viewport={"width": 1280, "height": 720}, locale="zh-CN", args=args,
         )
-
         self.page = await self.context.new_page()
         await self.page.goto(self.DEEPSEEK_URL, timeout=30000)
-        # Wait for page ready instead of fixed sleep
-        try:
-            await self.page.wait_for_selector('textarea', timeout=10000)
-        except Exception:
-            await asyncio.sleep(1)
-
+        await self._wait_for_cloudflare()
         await self._check_login_state()
 
+    async def _wait_for_cloudflare(self):
+        deadline = time.time() + 25
+        last_url = ""
+        while time.time() < deadline:
+            try:
+                url = self.page.url
+                if url == last_url and "/cdn-cgi" not in url:
+                    try:
+                        await self.page.wait_for_selector(
+                            'textarea, input[type="text"], input[type="password"]',
+                            timeout=3000)
+                        return
+                    except Exception:
+                        pass
+                last_url = url
+            except Exception:
+                pass
+            await asyncio.sleep(1)
+        await asyncio.sleep(2)
+
     async def _check_login_state(self):
         current_url = self.page.url
-
-        if '/sign_in' in current_url:
+        try:
+            await self.page.wait_for_selector("textarea", timeout=10000)
+            self._logged_in = True
+            self._ready = True
+            if self._logged_in:
+                await self._check_mute()
+            return
+        except Exception:
+            pass
+        if "/sign_in" in current_url:
             await self._auto_login()
         else:
             try:
-                await self.page.wait_for_selector('textarea', timeout=8000)
+                await self.page.wait_for_selector("textarea", timeout=8000)
                 self._logged_in = True
                 self._ready = True
             except Exception:
                 await self._auto_login()
-
-        # 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, ''];
+                const t = document.body.innerText || '';
+                const m = t.match(/禁言至\\s*(\\d{4}[-年]\\d{1,2}[-月]\\d{1,2}[日]?\\s*\\d{1,2}:\\d{2})/);
+                if (m) return [true, m[1]];
+                if (t.includes('禁言')) return [true, ''];
                 return [false, ''];
             }""")
             self._is_muted = muted
@@ -106,448 +122,309 @@ class DeepSeekBrowser:
             self._is_muted = False
             self._muted_until = ""
 
-    def is_muted(self) -> bool:
-        return getattr(self, '_is_muted', False)
+    def is_muted(self):
+        return getattr(self, "_is_muted", False)
 
-    def muted_until(self) -> str:
-        return getattr(self, '_muted_until', "")
+    def muted_until(self):
+        return getattr(self, "_muted_until", "")
 
     async def _auto_login(self):
         logger.info("Logging in as %s...", self.email)
+        await self._wait_for_cloudflare()
 
-        # 1. 先等待页面加载完成（任意输入框出现），防止因为 Cloudflare 还在转圈导致直接尝试点击失败
-        try:
-            any_input = self.page.locator('input').first
-            await any_input.wait_for(state="visible", timeout=15000)
-        except Exception:
-            pass
-
-        # 2. 尝试切换到“密码登录”模式（如果页面默认是手机验证码登录）
         try:
             pwd_tab = self.page.locator('text="密码登录"').first
             if await pwd_tab.is_visible():
                 await pwd_tab.click()
-                await asyncio.sleep(0.1)
+                await asyncio.sleep(0.3)
         except Exception as e:
-            logger.debug("No password login tab found or error: %s", e)
+            logger.debug("No password login tab: %s", e)
 
         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)
+            email_input = None
+            deadline = time.time() + 15
+            while time.time() < deadline:
+                for sel in [
+                    'input[placeholder*="邮箱"]',
+                    'input[placeholder*="手机号"]',
+                    'input[placeholder*="Email"]',
+                    'input.ds-input__input[type="text"]',
+                ]:
+                    el = self.page.locator(sel).first
+                    try:
+                        if await el.count() > 0 and await el.is_visible():
+                            email_input = el
+                            break
+                    except Exception:
+                        continue
+                if email_input:
+                    break
+                await asyncio.sleep(0.8)
+            if not email_input:
+                raise TimeoutError("Email input not found")
             await email_input.fill(self.email)
             await asyncio.sleep(0.1)
         except Exception as e:
-            try:
-                await self.page.screenshot(path=f"/tmp/login_fail_{self.email.replace('@','_at_')}.png")
-                logger.error("Screenshot saved to /tmp/login_fail_%s.png", self.email.replace('@', '_at_'))
-            except Exception:
-                pass
+            await self._save_screenshot("login_fail_email")
             logger.error("Email input error: %s", 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)
+            pwd = self.page.locator('input[type="password"]').first
+            await pwd.wait_for(state="visible", timeout=5000)
+            await pwd.fill(self.password)
             await asyncio.sleep(0.1)
         except Exception as e:
+            await self._save_screenshot("login_fail_password")
             logger.error("Password input error: %s", e)
             raise
 
         try:
-            login_button = self.page.locator('button:has-text("登录")').first
-            await login_button.click()
+            btn = self.page.locator('button:has-text("登录")').first
+            await btn.click()
             await asyncio.sleep(1.5)
         except Exception as e:
+            await self._save_screenshot("login_fail_button")
             logger.error("Login button error: %s", e)
             raise
 
         try:
-            await self.page.wait_for_selector('textarea', timeout=20000)
+            await self.page.wait_for_selector("textarea", timeout=20000)
             self._logged_in = True
             self._ready = True
-            logger.info("Login successful!")
+            logger.info("Login successful for %s", self.email)
         except Exception:
-            try:
-                await self.page.screenshot(path=f"/tmp/login_fail_{self.email.replace('@','_at_')}_final.png")
-                logger.error("Final login screenshot saved to /tmp/login_fail_%s_final.png", self.email.replace('@', '_at_'))
-            except Exception:
-                pass
-            raise Exception("Login failed")
-
-    async def _human_delay(self, min_ms: int = 5, max_ms: int = 30):
-        """Minimal delay for speed — just enough to avoid race conditions."""
-        delay = random.uniform(min_ms, max_ms) / 1000
-        await asyncio.sleep(delay)
+            await self._save_screenshot("login_fail_final")
+            raise Exception("Login failed — screenshot at /static/screenshots/")
 
     async def new_chat(self):
-        """Start a new chat by clicking the new-chat button instead of full page reload."""
         try:
-            # Try clicking the "new chat" button first (much faster than goto)
-            new_chat_btn = self.page.locator(
+            btn = self.page.locator(
                 'a:has-text("开启新对话"), button:has-text("开启新对话"), '
                 'a:has-text("新对话"), button:has-text("新对话"), '
                 '[class*="new-chat"], [class*="newChat"]'
             ).first
-            if await new_chat_btn.count() > 0:
-                await new_chat_btn.click()
-                await self.page.wait_for_selector('textarea', timeout=10000)
+            if await btn.count() > 0:
+                await btn.click()
+                await self.page.wait_for_selector("textarea", timeout=10000)
                 return
-
-            # Fallback: full page reload
             await self.page.goto(self.DEEPSEEK_URL, timeout=30000)
-            await self.page.wait_for_selector('textarea', timeout=15000)
+            await self.page.wait_for_selector("textarea", timeout=15000)
         except Exception as e:
             logger.error("New chat error: %s", e)
             raise
 
     async def delete_chat(self):
         try:
-            # Find the sidebar and active conversation
             chat_list = self.page.locator(
-                'nav, aside, [class*="sidebar"], [class*="Sidebar"], div:has-text("开启新对话")'
-            )
-            chat_list_count = await chat_list.count()
-            if chat_list_count == 0:
-                logger.debug("[delete_chat] no sidebar")
+                'nav, aside, [class*="sidebar"], [class*="Sidebar"], div:has-text("开启新对话")')
+            if await chat_list.count() == 0:
                 return
-
             active_item = chat_list.first.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
-                logger.debug("[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:
-                logger.debug("[delete_chat] no bbox")
+                '[class*="active"], [class*="selected"], [class*="current"]').first
+            if await active_item.count() == 0:
                 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;
+            result = await self.page.evaluate("""() => {
+                const a = document.querySelector('[class*="active"], [class*="selected"]');
+                if (!a) return 'no-active';
+                const walk = (n, d) => {
+                    if (d > 10) return null;
+                    for (const c of n.children || []) {
+                        const t = c.tagName, cls = (c.className || '').toString();
+                        if ((t === 'BUTTON' || t === 'svg' || cls.includes('icon')
+                             || cls.includes('more') || cls.includes('menu') || cls.includes('action'))
+                            && c.offsetWidth < 40 && c.offsetWidth > 0) return c;
+                        const f = walk(c, d + 1);
+                        if (f) return f;
                     }
                     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;
-                }
+                const icon = walk(a, 0);
+                if (icon) { icon.click(); return 'clicked'; }
+                const btn = a.querySelector('button, [role="button"]');
+                if (btn) { btn.click(); return 'fallback'; }
                 return 'no-icon';
             }""")
-            logger.debug("[delete_chat] icon click: %s", click_result)
+            logger.debug("[delete_chat] icon click: %s", result)
             await asyncio.sleep(0.5)
-
-            # 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:
-                logger.debug("[delete_chat] no delete option found")
+            del_btn = self.page.locator(':has-text("删除"), :has-text("Delete")').first
+            if await del_btn.count() == 0:
                 return
-
-            await delete_btn.click()
+            await del_btn.click()
             await asyncio.sleep(0.5)
-
-            # Confirm
-            confirm_btn = self.page.locator(
+            confirm = 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()
+                'button:has-text("Confirm"), button:has-text("Delete")').last
+            if await confirm.count() > 0:
+                await confirm.click()
                 await asyncio.sleep(1)
-                logger.debug("[delete_chat] done!")
-            else:
-                logger.debug("[delete_chat] no confirm btn")
-                
         except Exception as e:
             logger.warning("[delete_chat] error: %s", e)
 
-    async def switch_model(self, model: str):
+    async def switch_model(self, model):
         try:
-            # Inject a robust clicker that finds the innermost element containing specific text
-            # and clicks it directly via JS, bypassing Playwright's actionability checks.
-            click_js = """(texts) => {
+            js = """(texts) => {
                 const els = Array.from(document.querySelectorAll('*'));
-                const target = els.reverse().find(el => {
+                const t = els.reverse().find(el => {
                     if (!el.innerText || el.children.length > 0) return false;
-                    return texts.some(t => el.innerText.includes(t)) && el.offsetParent !== null;
+                    return texts.some(x => el.innerText.includes(x)) && el.offsetParent !== null;
                 });
-                if (target) {
-                    target.click();
-                    return true;
-                }
+                if (t) { t.click(); return true; }
                 return false;
             }"""
-
-            # 默认全局开启深度思考 (R1)，不再区分类别
-            await self.page.evaluate(click_js, ['深度思考', 'DeepThink', 'R1'])
+            await self.page.evaluate(js, ['深度思考', 'DeepThink', 'R1'])
             await asyncio.sleep(0.5)
-
         except Exception as e:
-            logger.warning("[switch_model] click error: %s", e)
+            logger.warning("[switch_model] error: %s", e)
 
-    async def send_message(self, prompt: str, timeout: int = 120, model: str = "deepseek-chat") -> dict:
-        """Send message and return {'content': str, 'reasoning_content': str}."""
+    async def send_message(self, prompt, timeout=120, model="deepseek-chat"):
         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 input_field.fill(prompt)
+            inp = self.page.locator("textarea").first
+            await inp.wait_for(state="visible", timeout=15000)
+            await inp.fill(prompt)
             await self._human_delay()
-            await input_field.press('Enter')
-
+            await inp.press("Enter")
             result = await self._wait_for_response(timeout, prompt)
-
             asyncio.create_task(self._safe_delete_chat())
-
             return result
         except Exception as e:
             logger.error("Send message error: %s", e)
             raise
 
     async def _safe_delete_chat(self):
-        """Non-blocking delete chat wrapper."""
         try:
             await self.delete_chat()
         except Exception as e:
             logger.debug("[safe_delete] %s", e)
 
-    # JavaScript to extract thinking and answer content from DOM
     _EXTRACT_JS = """() => {
-        const result = {thinking: '', answer: '', done: false};
-
-        // Find all assistant message containers (last one is current)
+        const r = {thinking: '', answer: '', done: false};
         const msgs = document.querySelectorAll(
-            '[class*="assistant"], [class*="bot-"], [class*="message--"], [class*="message-wrapper"], [class*="chat-message"]'
-        );
-        let lastMsg = null;
+            '[class*="assistant"], [class*="bot-"], [class*="message--"], [class*="message-wrapper"], [class*="chat-message"]');
+        let last = null;
         for (let i = msgs.length - 1; i >= 0; i--) {
-            const cls = (msgs[i].className || '').toLowerCase();
-            if (!cls.includes('user')) {
-                lastMsg = msgs[i];
-                break;
-            }
-        }
-        
-        // If no assistant message container found yet, it means generation hasn't started. Wait.
-        if (!lastMsg) {
-            return result;
+            if (!(msgs[i].className || '').toLowerCase().includes('user')) { last = msgs[i]; break; }
         }
-        const scope = lastMsg;
-
-        // 1. Try to extract from Markdown blocks
+        if (!last) return r;
+        const scope = last;
         const mdEls = Array.from(scope.querySelectorAll(
-            '[class*="markdown"], [class*="Markdown"], [class*="answer"], [class*="content"]'
-        ));
-        // Filter out nested ones to get top-level blocks
-        const topMdEls = mdEls.filter(el => !mdEls.some(p => p !== el && p.contains(el)));
-        
-        let extractedThink = '';
-        let extractedAns = '';
-        
-        if (topMdEls.length >= 2) {
-            // Usually if there are 2 blocks, first is reasoning, last is answer
-            extractedThink = topMdEls[0].innerText.trim();
-            extractedAns = topMdEls[topMdEls.length - 1].innerText.trim();
-        } else if (topMdEls.length === 1) {
-            // Check if there's a visible "深度思考" toggle near it, or assume it's answer
-            const t = topMdEls[0].innerText.trim();
-            // If the whole scope text implies it's still thinking and no answer yet
-            if (scope.innerText.includes('深度思考') && !scope.innerText.includes('已深度思考')) {
-                extractedThink = t;
-            } else {
-                extractedAns = t;
-            }
+            '[class*="markdown"], [class*="Markdown"], [class*="answer"], [class*="content"]'));
+        const top = mdEls.filter(el => !mdEls.some(p => p !== el && p.contains(el)));
+        let think = '', ans = '';
+        if (top.length >= 2) { think = top[0].innerText.trim(); ans = top[top.length - 1].innerText.trim(); }
+        else if (top.length === 1) {
+            const t = top[0].innerText.trim();
+            if (scope.innerText.includes('深度思考') && !scope.innerText.includes('已深度思考')) think = t;
+            else ans = t;
         }
-
-        // 2. Fallback: parse raw lines if blocks failed or if it's safer
-        const bodyText = scope.innerText || '';
-        const hasThinkMarker = bodyText.includes('深度思考') || bodyText.includes('极速思考') || bodyText.includes('思考过程');
-        
-        if (!extractedAns || (!extractedThink && hasThinkMarker)) {
-            const lines = bodyText.split('\\n').map(l => l.trim()).filter(Boolean);
-            const skip = ['智能搜索', '快速模式', '专家模式', '极速思考', '内容由 AI 生成', '开启新对话', '暂无历史对话'];
-            
-            let isThinking = false;
-            let thinkLines = [];
-            let ansLines = [];
-            
+        const bt = scope.innerText || '';
+        const hasMarker = bt.includes('深度思考') || bt.includes('极速思考') || bt.includes('思考过程');
+        if (!ans || (!think && hasMarker)) {
+            const lines = bt.split('\\n').map(l => l.trim()).filter(Boolean);
+            const skip = ['智能搜索','快速模式','专家模式','极速思考','内容由 AI 生成','开启新对话','暂无历史对话'];
+            let isTh = false, tl = [], al = [];
             for (const l of lines) {
                 if (skip.some(s => l === s)) continue;
-                
-                // UI markers are usually short
                 if (l.length < 30 && (l.includes('深度思考') || l.includes('极速思考') || l.includes('思考过程'))) {
-                    if (l.includes('已') || l.includes('用时') || l.includes('完成')) {
-                        isThinking = false;
-                    } else {
-                        isThinking = true;
-                    }
+                    isTh = !(l.includes('已') || l.includes('用时') || l.includes('完成'));
                     continue;
                 }
-                
-                if (isThinking) {
-                    thinkLines.push(l);
-                } else {
-                    ansLines.push(l);
-                }
+                if (isTh) tl.push(l); else al.push(l);
             }
-            
-            // Prefer fallback if it extracted something meaningful
-            if (thinkLines.length > 0) extractedThink = thinkLines.join('\\n');
-            if (ansLines.length > 0) extractedAns = ansLines.join('\\n');
-        }
-        
-        result.thinking = extractedThink;
-        result.answer = extractedAns;
-
-        // Check if response is complete
-        const stopBtn = document.querySelector('[class*="stop"], button[aria-label*="stop"]');
-        result.done = (!stopBtn || stopBtn.offsetParent === null);
-        
-        // If we haven't extracted any text at all, we are NOT done
-        if (!result.answer && !result.thinking) {
-            result.done = false;
+            if (tl.length) think = tl.join('\\n');
+            if (al.length) ans = al.join('\\n');
         }
-
-        return result;
+        r.thinking = think; r.answer = ans;
+        const sb = document.querySelector('[class*="stop"], button[aria-label*="stop"]');
+        r.done = (!sb || sb.offsetParent === null);
+        if (!r.answer && !r.thinking) r.done = false;
+        return r;
     }"""
 
-    async def _wait_for_response(self, timeout: int, prompt: str = "") -> dict:
-        """Wait for response and return {content, reasoning_content}."""
+    async def _wait_for_response(self, timeout, prompt=""):
         deadline = time.time() + timeout
         await asyncio.sleep(0.8)
-
-        last_answer = ""
-        last_thinking = ""
-        stable_count = 0
-
+        last_answer, last_thinking, stable = "", "", 0
         while time.time() < deadline:
             try:
                 result = await self.page.evaluate(self._EXTRACT_JS)
-                
-                answer = (result.get("answer") or "").strip()
-                thinking = (result.get("thinking") or "").strip()
-
-                if answer or thinking:
-                    if answer != last_answer or thinking != last_thinking:
-                        last_answer = answer
-                        last_thinking = thinking
-                        stable_count = 0
-                    else:
-                        stable_count += 1
-
-                    if stable_count >= 3:
-                        return {"content": last_answer, "reasoning_content": last_thinking}
-
-            except Exception:
-                pass
-
+            except Exception as e:
+                err = str(e)
+                if "Target crashed" in err or "Target closed" in err:
+                    logger.error("[_wait_for_response] Browser crashed: %s", e)
+                    raise
+                await asyncio.sleep(0.5)
+                continue
+            answer = (result.get("answer") or "").strip()
+            thinking = (result.get("thinking") or "").strip()
+            if answer or thinking:
+                if answer != last_answer or thinking != last_thinking:
+                    last_answer, last_thinking, stable = answer, thinking, 0
+                else:
+                    stable += 1
+                if stable >= 3:
+                    return {"content": last_answer, "reasoning_content": last_thinking}
             await asyncio.sleep(0.5)
-
         if last_answer or last_thinking:
-            logger.info("[_wait_for_response] Done. Think len: %d, Ans len: %d", len(last_thinking), len(last_answer))
             return {"content": last_answer, "reasoning_content": last_thinking}
-
         raise TimeoutError("No response received")
 
-    async def stream_message(self, prompt: str, timeout: int = 120, model: str = "deepseek-chat") -> AsyncGenerator[dict, None]:
-        """Stream response, yielding dicts: {'type': 'thinking'|'content', 'chunk': str}."""
+    async def stream_message(self, prompt, timeout=120, model="deepseek-chat"):
         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 input_field.fill(prompt)
+            inp = self.page.locator("textarea").first
+            await inp.wait_for(state="visible", timeout=15000)
+            await inp.fill(prompt)
             await self._human_delay()
-            await input_field.press('Enter')
-
+            await inp.press("Enter")
             deadline = time.time() + timeout
-            last_thinking = ""
-            last_answer = ""
-            stable_count = 0
-
+            last_thinking, last_answer, stable = "", "", 0
             await asyncio.sleep(0.8)
-
             while time.time() < deadline:
                 try:
                     result = await self.page.evaluate(self._EXTRACT_JS)
-
-                    thinking = (result.get("thinking") or "").strip()
-                    answer = (result.get("answer") or "").strip()
-
-                    if thinking and thinking != last_thinking:
-                        new_think = thinking[len(last_thinking):]
-                        if new_think:
-                            logger.info("[Stream] Thinking: %s", new_think.replace('\\n', ' ')[:50])
-                            yield {"type": "thinking", "chunk": new_think}
-                        last_thinking = thinking
-
-                    if answer and answer != last_answer:
-                        new_ans = answer[len(last_answer):]
-                        if new_ans:
-                            logger.info("[Stream] Content: %s", new_ans.replace('\\n', ' ')[:50])
-                            yield {"type": "content", "chunk": new_ans}
-                        last_answer = answer
-                        stable_count = 0
-                    elif answer:
-                        stable_count += 1
-
-                    if stable_count >= 3:
-                        break
-
-                except Exception:
-                    pass
-
+                except Exception as e:
+                    err = str(e)
+                    if "Target crashed" in err or "Target closed" in err:
+                        logger.error("[stream_message] Browser crashed: %s", e)
+                        raise
+                    await asyncio.sleep(0.3)
+                    continue
+                thinking = (result.get("thinking") or "").strip()
+                answer = (result.get("answer") or "").strip()
+                if thinking and thinking != last_thinking:
+                    new = thinking[len(last_thinking):]
+                    if new:
+                        yield {"type": "thinking", "chunk": new}
+                    last_thinking = thinking
+                if answer and answer != last_answer:
+                    new = answer[len(last_answer):]
+                    if new:
+                        yield {"type": "content", "chunk": new}
+                    last_answer, stable = answer, 0
+                elif answer:
+                    stable += 1
+                if stable >= 3:
+                    break
                 await asyncio.sleep(0.3)
-
             try:
                 await self.delete_chat()
             except Exception as e:
-                logger.warning("[stream_message] delete_chat cleanup error: %s", e)
-
+                logger.warning("[stream_message] cleanup error: %s", e)
         except Exception as e:
             logger.error("Stream message error: %s", e)
             raise
 
     async def close(self):
         if self.context:
-            await self.context.close()
+            try:
+                await self.context.close()
+            except Exception as e:
+                logger.debug("Error closing browser: %s", e)
+            self.context = None
+            self.page = None
+            self._logged_in = False
+            self._ready = False

main.py

@@ -382,7 +382,7 @@ async def import_accounts(request: Request, admin_key: str = Header(...)):
 
     # 异步触发新导入账号的并行预登录
     async def prelogin_new_accounts():
-        sem = asyncio.Semaphore(20)
+        sem = asyncio.Semaphore(10)  # 最多同时 10 个登录，避免浏览器启动过载
         async def _login_one(account):
             async with sem:
                 try:
@@ -655,6 +655,30 @@ async def clear_logs(admin_key: str = Header(...)):
     return {"ok": True}
 
 
+SCREENSHOT_DIR = Path(__file__).parent / "static" / "screenshots"
+
+
+@app.get("/admin/screenshots")
+async def list_screenshots(admin_key: str = Header(...)):
+    """List debug screenshots with file sizes and timestamps."""
+    if admin_key != config.server.admin_key:
+        raise HTTPException(status_code=401, detail="Invalid admin key")
+    if not SCREENSHOT_DIR.exists():
+        return {"screenshots": []}
+    files = sorted(SCREENSHOT_DIR.glob("*.png"), key=lambda p: p.stat().st_mtime, reverse=True)
+    return {
+        "screenshots": [
+            {
+                "name": f.name,
+                "url": f"/static/screenshots/{f.name}",
+                "size_kb": round(f.stat().st_size / 1024, 1),
+                "time": time.strftime("%m-%d %H:%M", time.localtime(f.stat().st_mtime)),
+            }
+            for f in files[:50]
+        ]
+    }
+
+
 @app.post("/admin/logs/level")
 async def set_log_level(request: Request, admin_key: str = Header(...)):
     if admin_key != config.server.admin_key:
@@ -696,7 +720,7 @@ async def startup():
 
 async def _prelogin_all():
     """并行预登录全部账号，信号量控制并发避免打崩服务器。"""
-    sem = asyncio.Semaphore(20)
+    sem = asyncio.Semaphore(10)  # 最多同时 10 个登录，避免浏览器启动过载
     total = len(manager.accounts)
     done = 0
 

static/index.html

@@ -384,6 +384,19 @@ html.light-mode .log-viewer{background:rgba(0,0,0,.04);color:#475569}
   </div>
 </div>
 
+<!-- Screenshots -->
+<div class="card span-full" style="animation-delay:.5s">
+  <div class="card-header">
+    <h2><span class="icon">📸</span> 调试截图</h2>
+    <button class="btn btn-sm" onclick="loadScreenshots()">刷新</button>
+  </div>
+  <div class="card-body" style="padding:10px">
+    <div id="ssList" style="display:flex;flex-wrap:wrap;gap:8px;font-size:11px;color:var(--text-dim)">
+      加载中…
+    </div>
+  </div>
+</div>
+
 </main>
 </div>
 
@@ -633,11 +646,12 @@ async function loadAll(){await loadStats();await loadAccounts()}
 
 document.getElementById('prompt').addEventListener('keydown',e=>{if(e.ctrlKey&&e.key==='Enter')sendMsg()});
 
-let _pollTimer=null,_logTimer=null;
+let _pollTimer=null,_logTimer=null,_ssTimer=null;
 function initApp(){
-  loadAll();loadSettings();loadLogs();
+  loadAll();loadSettings();loadLogs();loadScreenshots();
   if(!_pollTimer)_pollTimer=setInterval(loadAll,12000);
   if(!_logTimer)_logTimer=setInterval(loadLogs,3000);
+  if(!_ssTimer)_ssTimer=setInterval(loadScreenshots,30000);
 }
 
 async function loadSettings(){
@@ -697,6 +711,20 @@ async function setLevel(lvl){
     toast('日志级别: '+lvl,1);
   }catch(e){toast(e.message,0)}
 }
+
+async function loadScreenshots(){
+  try{
+    const d=await api('/admin/screenshots',{headers:{'admin-key':getAdminKey()}});
+    const el=document.getElementById('ssList');
+    if(!d.screenshots||!d.screenshots.length){el.innerHTML='<span>暂无截图</span>';return}
+    el.innerHTML=d.screenshots.map(s=>
+      `<a href="${s.url}" target="_blank" style="display:inline-flex;align-items:center;gap:4px;padding:4px 10px;background:var(--surface-solid);border:1px solid var(--border);border-radius:6px;color:var(--text);text-decoration:none;font-size:11px" title="${s.name}&#10;${s.time} · ${s.size_kb}KB">
+        🖼️ ${s.name.replace('login_fail_','').replace('_at_gmail.com','').substring(0,25)}
+        <span style="color:var(--text-dim);font-size:10px">${s.time}</span>
+      </a>`
+    ).join('');
+  }catch(e){}
+}
 </script>
 </body>
 </html>