# app/core/browser/connection.py import json import os import socket import threading import time import contextlib from typing import Optional, List, Dict, Any, TYPE_CHECKING from app.core.driver.drission_internals import connect_existing_browser from app.core.config import logger, BrowserConstants, BrowserConnectionError, SSEFormatter from app.core import cdp_hygiene from app.core.driver import browser_driver # P0-2 / P0-4:运行期 CDP 卫生补丁(释放 run_js 对象结果、Network.enable 缓冲上限) cdp_hygiene.install() if TYPE_CHECKING: from .main import BrowserCore from app.core.tab_pool import TabPoolManager, TabSession def _looks_like_transient_local_debug_error(error: Any) -> bool: text = str(error or "").strip().lower() if not text: return False if "winerror 10048" in text: return True if "max retries exceeded" in text and "127.0.0.1" in text and "/json" in text: return True if "failed to establish a new connection" in text and "127.0.0.1" in text: return True return False def _inspect_headless_or_windowless_browser(port: int, timeout: float = 0.5) -> Optional[Dict[str, str]]: """ 探测指定端口的 Chromium 浏览器是否处于无头(Headless)或无窗口/缺少页面标签页状态。 返回 None 表示不是无头(或者端口未开放/非 Chromium)。 """ import urllib.request import json port_int = int(port) # 显式使用空 ProxyHandler,避免系统或环境变量代理(如 HTTP_PROXY)拦截 loopback 探测 opener = urllib.request.build_opener(urllib.request.ProxyHandler({})) # 1. 检查进程启动参数 (若 psutil 可用,优先确认是否明确声明了 --headless 或 --no-startup-window) cmd_has_headless = False cmd_has_no_startup_window = False try: import psutil target_arg = f"--remote-debugging-port={port_int}" for proc in psutil.process_iter(["pid", "cmdline"]): try: cmdline_list = proc.info.get("cmdline") or [] # 过滤 Chromium 子进程(renderer/gpu/utility 等子进程必然包含 --type=,主进程不包含) if any(str(arg).startswith("--type=") for arg in cmdline_list): continue cmdline = " ".join(cmdline_list) if target_arg in cmdline: cmd_lower = cmdline.lower() if "--headless" in cmd_lower: cmd_has_headless = True if "--no-startup-window" in cmd_lower: cmd_has_no_startup_window = True if cmd_has_headless and cmd_has_no_startup_window: break except Exception: continue except Exception: pass if cmd_has_headless: return {"reason": "headless_arg", "detail": "浏览器启动参数显式包含 --headless"} # 2. 检查 /json/version version_url = f"http://127.0.0.1:{port_int}/json/version" try: req = urllib.request.Request(version_url, headers={"User-Agent": "UWAPI-Diagnostics"}) with opener.open(req, timeout=timeout) as resp: data = json.loads(resp.read().decode("utf-8", errors="ignore")) except Exception: return None browser_desc = str(data.get("Browser", "") or "") user_agent = str(data.get("User-Agent", "") or "") if "headless" in browser_desc.lower() or "headless" in user_agent.lower(): return { "reason": "headless", "detail": f"检测到无头浏览器 ({browser_desc or user_agent})", } # 3. 检查 /json 目标列表 (targets) targets_url = f"http://127.0.0.1:{port_int}/json" try: req = urllib.request.Request(targets_url, headers={"User-Agent": "UWAPI-Diagnostics"}) with opener.open(req, timeout=timeout) as resp: targets = json.loads(resp.read().decode("utf-8", errors="ignore")) if isinstance(targets, list): pages = [ t for t in targets if isinstance(t, dict) and str(t.get("type", "")).lower() == "page" ] if not pages: if cmd_has_no_startup_window: return { "reason": "no_startup_window", "detail": "浏览器带有 --no-startup-window 参数且当前无前台可视页面", } other_types = sorted(list({ str(t.get("type", "unknown")) for t in targets if isinstance(t, dict) and t.get("type") })) detail_types = ", ".join(other_types) if other_types else "无任何活动目标" return { "reason": "no_pages", "detail": f"无可视标签页(当前后台目标: {detail_types})", } except Exception: pass return None def _load_model_name_overrides_config() -> Optional[Dict[str, Any]]: config_path = "config/model_name_overrides.local.json" if not os.path.exists(config_path): return None try: with open(config_path, "r", encoding="utf-8-sig") as f: payload = json.load(f) return payload if isinstance(payload, dict) else None except Exception as e: logger.debug(f"加载模型显示名称本地配置失败: {e}") return None def _load_preset_overrides_config() -> Optional[Dict[str, Any]]: config_path = "config/preset_overrides.local.json" if not os.path.exists(config_path): return None try: with open(config_path, "r", encoding="utf-8-sig") as f: payload = json.load(f) return payload if isinstance(payload, dict) else None except Exception as e: logger.debug(f"加载预设本地配置失败: {e}") return None def _load_tab_pool_config() -> Dict: """从配置文件和环境变量加载标签页池配置""" config = { "max_tabs": 5, "min_tabs": 1, "idle_timeout": 300, "acquire_timeout": 60, "stuck_timeout": 180, "allocation_mode": "first_idle", "excluded_urls": [], "preserve_error_tabs": False, "auto_remember_url_presets": False, "model_name_overrides": {"sites": {}, "urls": {}}, "preset_overrides": {"urls": {}}, "route_groups": [], } # 从 browser_config.json 加载 try: config_path = "config/browser_config.json" if os.path.exists(config_path): with open(config_path, 'r', encoding='utf-8') as f: file_config = json.load(f) pool_config = file_config.get("tab_pool", {}) config.update(pool_config) except Exception as e: logger.debug(f"加载 tab_pool 配置失败: {e}") local_model_name_overrides = _load_model_name_overrides_config() if local_model_name_overrides is not None: config["model_name_overrides"] = local_model_name_overrides local_preset_overrides = _load_preset_overrides_config() if local_preset_overrides is not None: config["preset_overrides"] = local_preset_overrides # 环境变量覆盖 if os.getenv("MAX_TABS"): config["max_tabs"] = int(os.getenv("MAX_TABS")) if os.getenv("MIN_TABS"): config["min_tabs"] = int(os.getenv("MIN_TABS")) allowed_keys = { "max_tabs", "min_tabs", "idle_timeout", "acquire_timeout", "stuck_timeout", "allocation_mode", "excluded_urls", "preserve_error_tabs", "auto_remember_url_presets", "model_name_overrides", "preset_overrides", "route_groups", } return {key: value for key, value in config.items() if key in allowed_keys} class BrowserConnectionMixin: """浏览器连接管理、生命周期、Watchdog 及 Tab 巡检混入类""" @staticmethod def _to_bool_env(name: str, default: bool = False) -> bool: value = os.getenv(name) if value is None: return default return str(value).strip().lower() in {"1", "true", "yes", "y", "on"} def _shutdown_tab_pool_for_reconnect(self, reason: str = "reconnect") -> None: pool = getattr(self, "_tab_pool", None) if pool is None: return self._tab_pool = None try: pool.shutdown() logger.info(f"[BrowserCore] 已重置旧 TabPool ({reason})") except Exception as e: logger.warning(f"[BrowserCore] 重置旧 TabPool 失败 ({reason}): {e}") def _dispose_previous_browser_handle(self, browser_handle: Any, reason: str = "reconnect") -> None: if browser_handle is None: return if self._to_bool_env("BROWSER_RECONNECT_QUIT_OLD_HANDLE", False): try: browser_handle.quit(timeout=1, force=False, del_data=False) logger.info(f"[BrowserCore] 已关闭旧浏览器句柄 ({reason})") return except Exception as e: logger.debug(f"[BrowserCore] 关闭旧浏览器句柄失败 ({reason}): {e}") stopped = 0 for driver in [getattr(browser_handle, "_driver", None)]: stop = getattr(driver, "stop", None) if callable(stop): try: stop() stopped += 1 except Exception: pass try: all_drivers = getattr(browser_handle, "_all_drivers", {}) or {} for driver_group in list(all_drivers.values()): for driver in list(driver_group or []): stop = getattr(driver, "stop", None) if callable(stop): try: stop() stopped += 1 except Exception: pass except Exception: pass if stopped: logger.debug(f"[BrowserCore] 已释放旧 CDP driver 引用 ({reason}, count={stopped})") def _connect(self) -> bool: now = time.time() # 处于无头模式冷却期时快速返回,避免频繁阻塞 30 秒超时 if now < getattr(self, "_connect_retry_after", 0.0): return False previous_handle = getattr(self, "browser_handle", None) self._shutdown_tab_pool_for_reconnect("connect") # 端口未开启时直接快速失败,避免调用 DrissionPage 陷入 30 秒内部超时阻塞 if not self._is_debug_port_open(): logger.debug(f"[BrowserCore] 调试端口 {self.port} 未开放,跳过连接") self.browser_handle = None self.page = None self._connected = False return False # 快速预检:检查是否为无头或无窗口/缺少页面标签页 headless_info = None for attempt in range(3): headless_info = _inspect_headless_or_windowless_browser(self.port) if not headless_info: break # 明确的无头参数无需等待重试 if headless_info.get("reason") in {"headless", "headless_arg", "no_startup_window"}: break # 若仅是暂时无 page,等待 0.3s 重试(给正在启动的浏览器事件循环留出时间) if attempt < 2: time.sleep(0.3) if headless_info: detail = headless_info["detail"] reason = headless_info.get("reason") # 明确的无头/无窗口冷却 15 秒;仅缺少页面的瞬时状态设置温和冷却 3 秒 cooldown = 15.0 if reason in {"headless", "headless_arg", "no_startup_window"} else 3.0 self._connect_retry_after = now + cooldown last_diag = getattr(self, "_last_headless_diagnosis", None) last_log = getattr(self, "_last_headless_log_at", 0.0) if detail != last_diag or (now - last_log) >= 60.0: self._last_headless_diagnosis = detail self._last_headless_log_at = now logger.error( f"检测到受控浏览器(端口 {self.port})处于无头或无窗口模式: {detail}。受控模式需要有界面的正常浏览器,请关闭该后台进程后用启动器重新拉起" ) else: logger.debug( f"[BrowserCore] 仍处于无头/无窗口模式 ({detail}),已抑制重复报错" ) self.browser_handle = None self.page = None self._connected = False return False try: logger.debug(f"连接浏览器 127.0.0.1:{self.port}") self.browser_handle = connect_existing_browser(f"127.0.0.1:{self.port}") if previous_handle is not None and previous_handle is not self.browser_handle: self._dispose_previous_browser_handle(previous_handle, "connect") try: self.page = self.browser_handle.latest_tab except Exception: self.page = None self._connected = True self._last_headless_diagnosis = None self._start_connection_watchdog() logger.info("浏览器连接成功") return True except Exception as e: # 连接失败时,进行无头/无窗口诊断 headless_info = _inspect_headless_or_windowless_browser(self.port) if headless_info: detail = headless_info["detail"] self._connect_retry_after = now + 15.0 last_diag = getattr(self, "_last_headless_diagnosis", None) last_log = getattr(self, "_last_headless_log_at", 0.0) if detail != last_diag or (now - last_log) >= 60.0: self._last_headless_diagnosis = detail self._last_headless_log_at = now logger.error( f"检测到受控浏览器(端口 {self.port})处于无头或无窗口模式: {detail}。受控模式需要有界面的正常浏览器,请关闭该后台进程后用启动器重新拉起" ) else: logger.debug( f"[BrowserCore] 仍处于无头/无窗口模式 ({detail}),已抑制重复报错" ) else: logger.error(f"浏览器连接失败: {e}") self.browser_handle = None self.page = None self._connected = False return False def _is_debug_port_open(self, timeout: float = 0.4) -> bool: try: with socket.create_connection(("127.0.0.1", int(self.port)), timeout=float(timeout)): self._last_debug_port_error = "" return True except Exception as e: self._last_debug_port_error = str(e) return False def _probe_browser_connection_via_cdp(self) -> bool: """Prefer the long-lived CDP session over spawning /json short connections.""" browser = self.get_browser_handle() if not browser or not hasattr(browser, "_run_cdp"): return False try: result = browser_driver(browser).run_cdp("Target.getTargets") or {} target_infos = result.get("targetInfos") return isinstance(target_infos, list) except Exception: return False def _list_tabs_via_cdp(self) -> List[Any]: browser = self.get_browser_handle() if not browser or not hasattr(browser, "_run_cdp"): return [] try: result = browser_driver(browser).run_cdp("Target.getTargets") or {} target_infos = result.get("targetInfos") or [] except Exception: return [] tabs: List[Any] = [] for info in target_infos: if not isinstance(info, dict): continue if str(info.get("type") or "").strip().lower() != "page": continue target_id = str(info.get("targetId") or "").strip() if not target_id: continue try: resolved = browser.get_tab(target_id) except Exception: resolved = None tabs.append(resolved or target_id) return tabs def _log_get_tabs_fallback(self, message: str, error: Any = None) -> None: now = time.time() if now - self._last_get_tabs_fallback_log_at < 10.0: return self._last_get_tabs_fallback_log_at = now if _looks_like_transient_local_debug_error(error): logger.debug(message) else: logger.warning(message) def _probe_browser_connection(self) -> bool: """Lightweight liveness probe for the underlying browser session.""" return self._probe_browser_connection_via_cdp() def get_browser_handle(self): if self.browser_handle is not None: return self.browser_handle browser = getattr(self.page, "browser", None) if browser is not None: self.browser_handle = browser return browser return self.page def get_tabs(self): browser = self.get_browser_handle() if browser is None: raise BrowserConnectionError("无法连接到浏览器") cdp_tabs = self._list_tabs_via_cdp() if cdp_tabs: self._get_tabs_retry_after = 0.0 return cdp_tabs now = time.time() if now < self._get_tabs_retry_after: return [] try: tabs = browser.get_tabs() self._get_tabs_retry_after = 0.0 return tabs except Exception as e: self._get_tabs_retry_after = max(self._get_tabs_retry_after, time.time() + 5.0) fallback_tabs = self._list_tabs_via_cdp() if fallback_tabs: self._log_get_tabs_fallback( f"[BrowserCore] browser.get_tabs() 失败,回退到 Target.getTargets: {e}", error=e, ) return fallback_tabs raise def get_tab_ids(self) -> List[str]: browser = self.get_browser_handle() if browser is None: raise BrowserConnectionError("无法连接到浏览器") return list(getattr(browser, "tab_ids", []) or []) def get_tab(self, id_or_num=None): browser = self.get_browser_handle() if browser is None: raise BrowserConnectionError("无法连接到浏览器") return browser.get_tab(id_or_num) def get_latest_tab(self): browser = self.get_browser_handle() if browser is None: raise BrowserConnectionError("无法连接到浏览器") return browser.latest_tab def _get_watchdog_tab_snapshot(self) -> str: try: if not self._tab_pool: return "tab_pool=uninitialized" if hasattr(self._tab_pool, "get_watchdog_summary"): status = self._tab_pool.get_watchdog_summary(limit=4) else: status = self._tab_pool.get_status() total = int(status.get("total", 0) or 0) idle = int(status.get("idle", 0) or 0) busy = int(status.get("busy", 0) or 0) tabs = status.get("tabs") or [] labels = [] for item in tabs[:4]: if not isinstance(item, dict): continue labels.append( f"{item.get('id', '?')}:{item.get('status', '?')}:{'iso' if item.get('is_isolated_context') else 'shared'}" ) extra = f", tabs=[{', '.join(labels)}]" if labels else "" return f"tab_pool(total={total}, idle={idle}, busy={busy}{extra})" except Exception as e: return f"tab_pool=error({e})" @staticmethod def _get_watchdog_float_env(name: str, default: float, minimum: float = 0.5) -> float: try: value = float(os.getenv(name, str(default))) except Exception: return default return max(float(minimum), value) def _has_recent_watchdog_activity(self) -> bool: now = time.time() recent_window = self._get_watchdog_float_env( "BROWSER_WATCHDOG_RECENT_ACTIVITY_WINDOW", 60.0, minimum=1.0, ) try: from app.services.request_manager import request_manager status = request_manager.get_status() if int(status.get("running_count", 0) or 0) > 0: self._last_watchdog_activity_at = now return True except Exception: return True try: pool = self._tab_pool sessions = pool.get_sessions_snapshot() if pool is not None else [] for session in sessions: status_value = getattr(getattr(session, "status", None), "value", "") if status_value == "busy": self._last_watchdog_activity_at = now return True except Exception: return True last_activity = float(getattr(self, "_last_watchdog_activity_at", 0.0) or 0.0) return bool(last_activity and now - last_activity < recent_window) def _get_connection_watchdog_interval(self) -> float: active_interval = self._get_watchdog_float_env( "BROWSER_WATCHDOG_ACTIVE_INTERVAL", 3.0, minimum=0.5, ) idle_interval = self._get_watchdog_float_env( "BROWSER_WATCHDOG_IDLE_INTERVAL", 5.0, minimum=active_interval, ) return active_interval if self._has_recent_watchdog_activity() else idle_interval def _connection_watchdog_loop(self) -> None: while not self._watchdog_stop.wait(self._get_connection_watchdog_interval()): try: pool = self._tab_pool if pool is not None: pool.run_watchdog_tick() except Exception as e: logger.debug(f"[BrowserWatchdog] 标签页巡检异常(忽略): {e}") port_open = self._is_debug_port_open() session_alive = self._probe_browser_connection() health = "alive" if session_alive else ("port_only" if port_open else "dead") if health == self._last_watchdog_health: continue snapshot = self._get_watchdog_tab_snapshot() if health == "alive": if port_open: logger.info( f"[BrowserWatchdog] 受控浏览器连接正常 (port={self.port}, session=alive, {snapshot})" ) elif _looks_like_transient_local_debug_error(self._last_debug_port_error): logger.debug( f"[BrowserWatchdog] 长连接正常,已忽略瞬时调试端口探测失败 " f"(port={self.port}, session=alive, {snapshot})" ) else: logger.info( f"[BrowserWatchdog] 受控浏览器连接正常 " f"(port={self.port}, session=alive, port_probe=failed, {snapshot})" ) elif health == "port_only": logger.warning( f"[BrowserWatchdog] 调试端口可达,但当前页面会话已失效 " f"(port={self.port}, session=dead, connected={self._connected}, {snapshot})" ) else: detail = "" if self._last_debug_port_error and not _looks_like_transient_local_debug_error(self._last_debug_port_error): detail = f", probe_error={self._last_debug_port_error}" logger.error( f"[BrowserWatchdog] 受控浏览器调试端口不可达 " f"(port={self.port}, connected={self._connected}, {snapshot}{detail})" ) self._last_watchdog_port_open = port_open self._last_watchdog_session_alive = session_alive self._last_watchdog_health = health def _start_connection_watchdog(self) -> None: if self._watchdog_thread and self._watchdog_thread.is_alive(): return self._watchdog_stop.clear() self._last_watchdog_port_open = None self._last_watchdog_session_alive = None self._last_watchdog_health = None self._watchdog_thread = threading.Thread( target=self._connection_watchdog_loop, daemon=True, name="browser-connection-watchdog", ) self._watchdog_thread.start() def health_check(self) -> Dict[str, Any]: result = { "status": "unhealthy", "connected": False, "port": self.port, "tab_pool": None, "error": None } try: if not self.get_browser_handle(): if not self._connect(): result["error"] = "无法连接到浏览器" return result elif not self._probe_browser_connection(): previous_handle = self.browser_handle self._connected = False self.browser_handle = None self.page = None self._dispose_previous_browser_handle(previous_handle, "health_check") if not self._connect(): result["error"] = "无法连接到浏览器" return result result["status"] = "healthy" result["connected"] = True if self._tab_pool: result["tab_pool"] = self._tab_pool.get_status() except Exception as e: result["error"] = str(e) self._connected = False return result def ensure_connection(self) -> bool: if self._connected: if self._probe_browser_connection(): return True previous_handle = self.browser_handle self._connected = False self.browser_handle = None self.page = None self._dispose_previous_browser_handle(previous_handle, "ensure_connection") return self._connect() def get_active_tab(self): """ 获取一个可用的标签页(兼容旧接口) 注意:新代码应使用 execute_workflow_with_session """ # 生成临时任务 ID task_id = f"legacy_{int(time.time() * 1000)}" session = self.tab_pool.acquire(task_id, timeout=30) if session is None: raise BrowserConnectionError("无法获取可用标签页") return session.tab @contextlib.contextmanager def get_temporary_tab(self, timeout: int = 30): """ 获取临时标签页的上下文管理器(推荐使用) 使用方式: with browser.get_temporary_tab() as tab: elements = tab.eles(selector) # 退出 with 块后自动释放 Args: timeout: 获取标签页的超时时间(秒) Yields: tab: 浏览器标签页对象 Raises: BrowserConnectionError: 无法获取可用标签页时抛出 """ task_id = f"temp_{time.time_ns()}" session = None try: session = self.tab_pool.acquire(task_id, timeout=timeout) if session is None: raise BrowserConnectionError("无法获取可用标签页,服务繁忙请稍后重试") logger.debug(f"[{session.id}] 临时标签页已分配") yield session.tab finally: if session is not None: self.tab_pool.release(session.id, expected_task_id=task_id) logger.debug(f"[{session.id}] 临时标签页已释放") def get_pool_status(self) -> Dict: """获取标签页池状态""" if self._tab_pool: return self._tab_pool.get_status() return {"initialized": False} def _check_page_status(self, tab) -> Dict[str, Any]: """检查页面状态""" result = {"ready": True, "reason": None} try: url = tab.url or "" if not url or url in ("about:blank", "chrome://newtab/"): result["ready"] = False result["reason"] = "请先打开目标AI网站" return result error_indicators = ["chrome-error://", "about:neterror"] for indicator in error_indicators: if indicator in url: result["ready"] = False result["reason"] = "页面加载错误" return result except Exception as e: logger.debug(f"页面状态检查异常: {e}") return result