Jarvis-Brain 0.1.7.12__tar.gz

jarvis_brain-0.1.7.12/.gitignore

@@ -0,0 +1,4 @@
+.venv
+.idea
+call_test
+dist

jarvis_brain-0.1.7.12/PKG-INFO

@@ -0,0 +1,10 @@
+Metadata-Version: 2.4
+Name: Jarvis_Brain
+Version: 0.1.7.12
+Summary: Jarvis brain mcp
+Requires-Python: >=3.10
+Requires-Dist: beautifulsoup4
+Requires-Dist: curl-cffi
+Requires-Dist: drissionpage
+Requires-Dist: fastmcp
+Requires-Dist: minify-html

jarvis_brain-0.1.7.12/README.md

@@ -0,0 +1,246 @@
+# Jarvis Brain MCP
+
+<div align="center">
+
+一个基于 FastMCP 和 DrissionPage 的浏览器自动化 MCP 服务器
+
+[![Python Version](https://img.shields.io/badge/python-3.10+-blue.svg)](https://www.python.org/downloads/)
+[![Version](https://img.shields.io/badge/version-0.1.5.7-green.svg)](https://github.com/yourusername/jarvis-mcp)
+
+## 📖 简介
+
+Jarvis Brain MCP 是一个强大的浏览器自动化工具，通过 Model Context Protocol (MCP) 提供服务。它集成了 DrissionPage 浏览器控制能力，支持多浏览器实例管理、智能 WAF 检测、HTML 获取与压缩等功能，特别适用于网页爬取、自动化测试和反爬虫分析场景。
+
+## ✨ 核心特性
+
+### 🌐 浏览器管理
+- **多实例浏览器池**: 使用单例模式管理多个浏览器实例，支持并发操作
+- **标签页控制**: 创建、切换、关闭标签页，灵活管理浏览器标签
+- **智能端口分配**: 自动分配随机端口 (9223-9934)，避免端口冲突
+
+### 🛡️ WAF 检测
+- **多维度检测**: 对比 requests、有头浏览器、无头浏览器三种方式获取的 HTML
+- **Cookie 特征识别**: 自动识别瑞数、加速乐等常见 WAF 的 Cookie 特征
+- **智能推荐**: 根据检测结果推荐最适合的采集方案（requests / headless / head）
+
+### 📄 HTML 处理
+- **智能压缩**: 自动移除 style、script、meta 标签及相关属性
+- **压缩比计算**: 实时计算压缩率，用于 WAF 检测判断
+- **本地保存**: 将获取的 HTML 保存到本地，便于后续分析
+
+### 🔍 元素检测
+- **CSS 选择器支持**: 检测页面中是否存在指定的 CSS 选择器元素
+- **智能格式化**: 自动添加 `css:` 前缀，简化使用
+
+## 🚀 快速开始
+
+### 安装
+
+```bash
+pip install Jarvis_Brain
+```
+
+或从源码安装：
+
+```bash
+git clone https://github.com/yourusername/jarvis-mcp.git
+cd jarvis-mcp
+pip install -e .
+```
+
+## 🛠️ MCP 工具列表
+
+### TeamNode-Dp 模块
+
+#### 1. visit_url
+打开指定 URL 并创建浏览器实例。
+
+**参数:**
+- `url` (str): 要访问的网页 URL
+
+**返回:**
+- `message`: 操作结果消息
+- `tab_id`: 标签页 ID
+- `browser_port`: 浏览器端口号
+
+#### 2. get_html
+获取指定标签页的 HTML 源码并保存到本地。
+
+**参数:**
+- `browser_port` (int): 浏览器端口号
+- `tab_id` (str): 标签页 ID
+
+**返回:**
+- `message`: 操作结果消息
+- `tab_id`: 标签页 ID
+- `html_local_path`: HTML 文件保存路径
+
+#### 3. get_new_tab
+在指定浏览器中创建新标签页并打开 URL。
+
+**参数:**
+- `browser_port` (int): 浏览器端口号
+- `url` (str): 要访问的 URL
+
+**返回:**
+- `message`: 操作结果消息
+- `tab_id`: 新标签页 ID
+
+#### 4. switch_tab
+切换到指定的标签页。
+
+**参数:**
+- `browser_port` (int): 浏览器端口号
+- `tab_id` (str): 要切换到的标签页 ID
+
+**返回:**
+- `message`: 操作结果消息
+
+#### 5. close_tab
+关闭指定的标签页。
+
+**参数:**
+- `browser_port` (int): 浏览器端口号
+- `tab_id` (str): 要关闭的标签页 ID
+
+**返回:**
+- `message`: 操作结果消息
+
+#### 6. check_selector
+检查标签页中是否存在指定的 CSS 选择器元素。
+
+**参数:**
+- `browser_port` (int): 浏览器端口号
+- `tab_id` (str): 标签页 ID
+- `css_selector` (str): CSS 选择器
+
+**返回:**
+- `message`: 操作结果消息
+- `tab_id`: 标签页 ID
+- `selector`: 完整的选择器
+- `selector_ele_exist` (bool): 元素是否存在
+
+### JarvisNode 模块
+
+#### 7. assert_waf
+智能检测网页是否使用了 WAF 及页面渲染类型。
+
+**检测原理:**
+1. 通过 Cookie 特征识别已知 WAF（瑞数、加速乐等）
+2. 对比 requests、无头浏览器、有头浏览器获取的 HTML 压缩比
+3. 根据压缩比差异判断页面类型和推荐采集方案
+
+**参数:**
+- `browser_port` (int): 浏览器端口号
+- `tab_id` (str): 标签页 ID
+
+**返回:**
+- `message`: 操作结果消息
+- `tab_id`: 标签页 ID
+- `recommend_team`: 推荐的采集方案
+  - `requests`: 静态页面，无防护
+  - `drissionpage_headless`: 动态页面或有 requests 防护
+  - `drissionpage_head`: 有无头检测或复杂 WAF
+- `raw_head_rate_difference`: requests 与有头浏览器压缩比差异
+- `raw_headless_rate_difference`: requests 与无头浏览器压缩比差异
+- `head_headless_rate_difference`: 有头与无头浏览器压缩比差异
+
+## 📊 WAF 检测逻辑
+
+### 判定规则
+
+| 场景 | requests vs 有头 | requests vs 无头 | 有头 vs 无头 | 推荐方案 | 说明 |
+|------|------------------|------------------|--------------|----------|------|
+| 静态页面无防护 | < 40% | < 40% | < 40% | `requests` | 三种方式结果一致 |
+| 动态页面 / requests 防护 | > 40% | > 40% | < 30% | `drissionpage_headless` | requests 拿不到正确结果 |
+| 无头检测 / 复杂 WAF | < 15% | > 40% | > 40% | `drissionpage_head` | 必须使用有头浏览器 |
+| 已知 WAF (Cookie) | - | - | - | `drissionpage_head` | 检测到瑞数/加速乐等 Cookie |
+| 状态码检测 | 412/521 | - | - | `drissionpage_head` | 瑞数(412)/加速乐(521) |
+
+### Cookie 特征库
+
+当前支持识别的 WAF：
+- **瑞数**: Cookie name 长度为 13，value 长度为 88
+- **加速乐**: Cookie name 包含 `_jsl`
+
+## 🏗️ 项目结构
+
+```
+Jarvis-mcp/
+├── mcp_tools/           # MCP 工具模块
+│   ├── __init__.py
+│   ├── main.py         # 主入口，注册 MCP 工具
+│   └── dp_tools.py     # DrissionPage 工具函数
+├── tools/              # 核心工具模块
+│   ├── __init__.py
+│   ├── browser_manager.py  # 浏览器池管理（单例模式）
+│   └── tools.py        # HTML 处理、WAF 检测等工具函数
+├── dist/               # 打包文件
+├── pyproject.toml      # 项目配置
+└── README.md          # 项目文档
+```
+
+## 🔧 技术栈
+
+- **[FastMCP](https://github.com/jlowin/fastmcp)**: MCP 服务器框架
+- **[DrissionPage](https://github.com/g1879/DrissionPage)**: 浏览器控制库
+- **[htmlmin](https://github.com/mankyd/htmlmin)**: HTML 压缩
+- **[BeautifulSoup4](https://www.crummy.com/software/BeautifulSoup/)**: HTML 解析
+- **[curl_cffi](https://github.com/yifeikong/curl_cffi)**: HTTP 请求库
+
+## 📝 使用方法
+
+### teamNode mcp配置
+
+```json
+"JarvisNode": {
+    "command": "uvx",
+    "args": ["--python", "3.11", "--from", "Jarvis_Brain@latest", "jarvis-mcp"],
+    "env": {
+        "MCP_MODULES": "TeamNode-Dp",
+        "BASE_CWD": os.getcwd(),
+    }
+},
+```
+
+### JarvisNode mcp配置
+
+```json
+"JarvisNode": {
+    "command": "uvx",
+    "args": ["--python", "3.11", "--from", "Jarvis_Brain@latest", "jarvis-mcp"],
+    "env": {
+        "MCP_MODULES": "TeamNode-Dp,JarvisNode",
+        "BASE_CWD": os.getcwd(),
+    }
+},
+```
+
+## 🌟 应用场景
+
+1. **网页爬虫**: 智能选择最优采集方案，提高爬取效率
+2. **反爬虫分析**: 快速识别网站使用的 WAF 类型
+3. **自动化测试**: 多浏览器实例并发测试
+4. **数据采集**: 处理动态渲染、反爬虫网站
+5. **安全研究**: 分析网站防护策略
+
+## 📄 许可证
+
+本项目采用 MIT 许可证。
+
+## 🤝 贡献
+
+欢迎提交 Issue 和 Pull Request！
+
+## 📮 联系方式
+
+如有问题或建议，请通过以下方式联系：
+
+- 提交 [Issue](https://github.com/yourusername/jarvis-mcp/issues)
+- 邮箱: your.email@example.com
+
+---
+
+<div align="center">
+Made with ❤️ by Jarvis Team
+</div>

jarvis_brain-0.1.7.12/mcp_tools/dp_tools.py

@@ -0,0 +1,206 @@
+import hashlib
+import json
+import os
+from typing import Any
+
+from fastmcp import FastMCP
+
+from tools.browser_manager import BrowserManager
+from tools.tools import compress_html, requests_html, dp_headless_html, assert_waf_cookie, dp_mcp_message_pack
+from tools.browser_proxy import DPProxyClient, DPProxyClientManager
+
+html_source_code_local_save_path = os.path.join(os.getcwd(), "html-source-code")
+waf_status_code_dict = {
+    412: "瑞数",
+    521: "加速乐"
+}
+# 一轮最大输入，以免单个html最大长度超过ai最大输入
+one_turn_max_token = 20000
+
+
+def register_visit_url(mcp: FastMCP, browser_manager: BrowserManager, client_manager: DPProxyClientManager):
+    @mcp.tool(name="visit_url",
+              description="使用Drissionpage打开url访问某个网站，并开始监听初始tab页的所有的XHR请求，当需要使用手机版浏览器Ua时use_mobile_user_agent为True")
+    async def visit_url(url: str, use_mobile_user_agent=False) -> dict[str, Any]:
+        mobile_user_agent = None
+        if use_mobile_user_agent:
+            mobile_user_agent = "Mozilla/5.0 (Linux; Android 6.0; Nexus 5 Build/MRA58N) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.0.0 Mobile Safari/537.36"
+        port, _browser = browser_manager.create_browser(mobile_user_agent)
+        tab = _browser.get_tab()
+        client_manager.create_client(tab)
+        tab.get(url)
+        tab_id = tab.tab_id
+        return dp_mcp_message_pack(
+            f"已在[{port}]端口创建浏览器对象，并已打开链接：{url}，打开的模式是：{'手机版' if use_mobile_user_agent else '电脑版'}",
+            tab_id=tab_id,
+            browser_port=port
+        )
+
+
+def register_get_html(mcp: FastMCP, browser_manager, client_manager: DPProxyClientManager):
+    @mcp.tool(name="get_html", description="使用Drissionpage获取某一个tab页的html")
+    async def get_html(browser_port: int, tab_id: str) -> dict[str, Any]:
+        _browser = browser_manager.get_browser(browser_port)
+        tab = _browser.get_tab(tab_id)
+        file_name_prefix = hashlib.md5(str(tab.title).encode('utf-8')).hexdigest()
+        if not os.path.exists(html_source_code_local_save_path):
+            os.makedirs(html_source_code_local_save_path)
+        min_html, compress_rate = compress_html(tab.html)
+        html_str_list = [min_html[i:i + one_turn_max_token] for i in range(0, len(min_html), one_turn_max_token)]
+        html_file_list = []
+        for index, html_str in enumerate(html_str_list):
+            file_name = file_name_prefix + f"_{tab_id}_segment{index}.html"
+            abs_path = os.path.join(html_source_code_local_save_path, file_name)
+            with open(abs_path, "w", encoding="utf-8") as f:
+                f.write(html_str)
+            html_file_list.append(abs_path)
+        message = f"已保存tab页：【{tab_id}】的html源码片段共{len(html_file_list)}个"
+        return dp_mcp_message_pack(message, tab_id=tab_id, htmls_local_path=html_file_list)
+
+
+def register_get_new_tab(mcp: FastMCP, browser_manager, client_manager: DPProxyClientManager):
+    @mcp.tool(name="get_new_tab",
+              description="使用Drissionpage创建一个新的tab页，在新的tab页中打开url，并开始监听新的tab页的所有XHR请求")
+    async def get_new_tab(browser_port: int, url: str) -> dict[str, Any]:
+        _browser = browser_manager.get_browser(browser_port)
+        tab = _browser.new_tab()
+        client_manager.create_client(tab)
+        tab.get(url)
+        _browser.activate_tab(tab)
+        tab_id = tab.tab_id
+        return dp_mcp_message_pack(f"已创建新的tab页，并打开链接：{url}", tab_id=tab_id)
+
+
+def register_switch_tab(mcp: FastMCP, browser_manager, client_manager: DPProxyClientManager):
+    @mcp.tool(name="switch_tab", description="根据传入的tab_id切换到对应的tab页", )
+    async def switch_tab(browser_port: int, tab_id: str) -> dict[str, Any]:
+        _browser = browser_manager.get_browser(browser_port)
+        _browser.activate_tab(tab_id)
+        return dp_mcp_message_pack(f"已将tab页:【{tab_id}】切换至最前端")
+
+
+def register_close_tab(mcp: FastMCP, browser_manager, client_manager: DPProxyClientManager):
+    @mcp.tool(name="close_tab", description="根据传入的tab_id关闭tab页", )
+    async def close_tab(browser_port, tab_id) -> dict[str, Any]:
+        _browser = browser_manager.get_browser(browser_port)
+        _browser.close_tabs(tab_id)
+        return dp_mcp_message_pack(f"已将tab页:【{tab_id}】关闭")
+
+
+def register_check_selector(mcp: FastMCP, browser_manager, client_manager: DPProxyClientManager):
+    @mcp.tool(name="check_selector",
+              description="查找tab页中是否包含元素，并返回元素attr_name所对应的值。"
+                          "当要选择的元素包含过多元素时，需要传入offset和page_size来分批查看元素，一般不建议调整page_size，更推荐你调整offset"
+                          "同时如果单个元素属性值太长，函数会进行截断。一般的单个元素的属性值超过300个字符的就会触发截断，截断后会在最后拼接'...'")
+    async def check_selector(browser_port: int, tab_id: str, css_selector: str, attr_name: str = "text",
+                             offset: int = 0, page_size: int = 10) -> dict[
+        str, Any]:
+        _browser = browser_manager.get_browser(browser_port)
+        target_tab = _browser.get_tab(tab_id)
+        css_selector = css_selector
+        if "css:" not in css_selector:
+            css_selector = "css:" + css_selector
+        target_eles = target_tab.eles(css_selector)
+        exist_flag = False
+        if len(target_eles) != 0:
+            exist_flag = True
+        if len(target_eles) > page_size:
+            target_eles = target_eles[offset:offset + page_size]
+        if attr_name == "text":
+            ele_text_list = [i.text.replace("\n", "") for i in target_eles]
+            attr_output = "\n".join(ele_text_list)
+        else:
+            attr_output = json.dumps([i.attr(attr_name) for i in target_eles])
+        # 对attr_output逐个截断，截断的长度为：一轮最大token除以元素个数+3个点+两个引号和逗号
+        slice_seg = max(300, one_turn_max_token // (page_size + 6))
+        attr_output = [attr_str[:slice_seg] + "..." for attr_str in attr_output]
+        return dp_mcp_message_pack(
+            f"已完成tab页:【{tab_id}】对：【{css_selector}】的检查",
+            tab_id=tab_id,
+            selector=css_selector,
+            selector_ele_exist=exist_flag,
+            page_size=page_size,
+            offset=offset,
+            attr_output=attr_output
+        )
+
+
+def register_quit_browser(mcp: FastMCP, browser_manager, client_manager: DPProxyClientManager):
+    @mcp.tool(name="quit_browser", description="退出浏览器会话，关闭浏览器")
+    async def quit_browser(browser_port: int) -> dict[str, Any]:
+        flag, _browser = browser_manager.remove_page(browser_port)
+        if flag:
+            _browser.quit()
+        return dp_mcp_message_pack(
+            f"浏览器[{browser_port}]，退出会话，关闭浏览器{'成功' if flag else '失败'}",
+            browser_port=browser_port,
+            quit_flag=flag
+        )
+
+
+def register_pop_first_packet(mcp: FastMCP, browser_manager, client_manager: DPProxyClientManager):
+    @mcp.tool(name="pop_first_packet",
+              description="每调用一次就会弹出传入的tab页所监听到的数据包中的第一个packet_message，当一个packet_message的response body过长时会被切分成多个包，具体一个请求是否还有下一个包，可以参考body_completed字段")
+    async def pop_first_packet(browser_port: int, tab_id: str) -> dict[str, Any]:
+        _browser = browser_manager.get_browser(browser_port)
+        client = client_manager.get_client(tab_id)
+        packet_message = client.pop_first_packet()
+        message = f"tab页:【{tab_id}】，暂时没有监听到XHR数据包"
+        if packet_message:
+            message = f"tab页:【{tab_id}】，监听到XHR数据包",
+        return dp_mcp_message_pack(
+            message,
+            browser_port=browser_port,
+            tab_id=tab_id,
+            packet_message=packet_message
+        )
+
+
+def register_assert_waf(mcp: FastMCP, browser_manager, client_manager: DPProxyClientManager):
+    @mcp.tool(name="assert_waf",
+              description="通过对比requests、有头浏览器、无头浏览器获取到的html，判断网页是否使用了waf以及是否为动态渲染的网页")
+    async def assert_waf(browser_port: int, tab_id: str) -> dict[str, Any]:
+        _browser = browser_manager.get_browser(browser_port)
+        target_tab = _browser.get_tab(tab_id)
+        recommend_team = "drissionpage_head"
+        head_cookies = target_tab.cookies()
+        # 通过cookie判断是否有waf
+        waf_flag, waf_type = assert_waf_cookie(head_cookies)
+        head_html = target_tab.html
+        min_head_html, head_rate = compress_html(head_html, only_text=True)
+        raw_html, status_code = requests_html(target_tab.url)
+        min_raw_html, raw_rate = compress_html(raw_html, only_text=True)
+        r_h_rate_diff = abs(head_rate - raw_rate)
+        # 如果有已知的防火墙，则不浪费时间使用无头获取html和压缩比了
+        if waf_flag or status_code in waf_status_code_dict.keys():
+            return dp_mcp_message_pack(
+                f"已完成tab页:【{tab_id}】的分析，该tab页存在waf",
+                tab_id=tab_id,
+                recommend_team=recommend_team,
+                raw_head_rate_difference=r_h_rate_diff,
+                raw_headless_rate_difference=0,
+                head_headless_rate_difference=0
+            )
+
+        headless_html = dp_headless_html(target_tab.url)
+        min_headless_html, headless_rate = compress_html(headless_html, only_text=True)
+        r_hless_rate_diff = abs(raw_rate - headless_rate)
+        h_hless_rate_diff = abs(head_rate - headless_rate)
+        # 最优情况：requests，dp有头和无头拿到的结果基本一致，认定为没有防护的静态网页
+        if r_h_rate_diff < 40 and r_hless_rate_diff < 40 and h_hless_rate_diff < 40:
+            recommend_team = "requests"
+        # 最差情况：requests，dp有头和无头拿到的结果差距都很大，认定为有浏览器无头检测+动态网页
+        # if r_h_rate_diff < 40 and r_hless_rate_diff < 40 and h_hless_rate_diff < 40:
+        # 较差1：dp有头和无头差距很小，但是requests拿不到正确结果，认定为有requests防护 or 动态网页
+        elif h_hless_rate_diff < 30 and r_hless_rate_diff > 40:
+            recommend_team = "drissionpage_headless"
+        # 较差2：有头和无头差距很大，但是requests和有头拿到的结果基本一致，认定为要么有别的没有防护requests的waf，或者间歇性的瑞数【此时应该拿有头的cookie去判断其中是否有瑞数特征，上面已经做了】
+        # if r_h_rate_diff < 15 and h_hless_rate_diff > 40:
+        return dp_mcp_message_pack(
+            f"已完成tab页:【{tab_id}】的分析，该tab页存在waf",
+            tab_id=tab_id,
+            recommend_team=recommend_team,
+            raw_head_rate_difference=r_h_rate_diff,
+            raw_headless_rate_difference=h_hless_rate_diff,
+            head_headless_rate_difference=h_hless_rate_diff
+        )

jarvis_brain-0.1.7.12/mcp_tools/main.py

@@ -0,0 +1,33 @@
+from fastmcp import FastMCP
+
+from mcp_tools.dp_tools import *
+from tools.browser_manager import browser_manager
+from tools.browser_proxy import client_manager
+
+mcp = FastMCP("Jarvis Brain Mcp Tools")
+
+# 根据环境变量加载模块
+enabled_modules = os.getenv("MCP_MODULES", "TeamNode-Dp").split(",")
+base_cwd = os.getenv("BASE_CWD", os.path.expanduser('~'))
+
+if "TeamNode-Dp" in enabled_modules:
+    # 页面管理
+    register_close_tab(mcp, browser_manager, client_manager)
+    register_switch_tab(mcp, browser_manager, client_manager)
+    register_get_new_tab(mcp, browser_manager, client_manager)
+    # 功能
+    register_visit_url(mcp, browser_manager, client_manager)
+    register_get_html(mcp, browser_manager, client_manager)
+    register_check_selector(mcp, browser_manager, client_manager)
+    register_pop_first_packet(mcp, browser_manager, client_manager)
+
+if "JarvisNode" in enabled_modules:
+    register_assert_waf(mcp, browser_manager, client_manager)
+
+
+def main():
+    mcp.run(transport="stdio")
+
+
+if __name__ == '__main__':
+    main()

jarvis_brain-0.1.7.12/pyproject.toml

@@ -0,0 +1,34 @@
+[project]
+name = "Jarvis_Brain"  # 别人下载时用的名字，必须在 PyPI 上唯一
+version = "0.1.7.12"
+description = "Jarvis brain mcp"
+dependencies = [
+    "fastmcp",
+    "DrissionPage",
+    "minify-html",
+    "beautifulsoup4",
+    "curl_cffi"
+]
+requires-python = ">=3.10"
+
+[project.scripts]
+jarvis-mcp = "mcp_tools.main:main"
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["mcp_tools", "tools"]
+
+[tool.hatch.build]
+exclude = [
+    "venv",
+    ".venv",
+    "env",
+    ".env",
+    ".idea",
+    "*.pyc",
+    "dist",
+    "call_test"
+]

jarvis_brain-0.1.7.12/tools/browser_manager.py

@@ -0,0 +1,52 @@
+"""浏览器池管理模块 - 单例模式确保状态共享"""
+import random
+from typing import Optional, Tuple
+import os
+from DrissionPage import ChromiumPage, ChromiumOptions
+import platform
+
+
+class BrowserManager:
+    """浏览器池管理器 - 使用单例模式"""
+    _instance = None
+
+    def __new__(cls):
+        if cls._instance is None:
+            cls._instance = super().__new__(cls)
+            cls._instance.browser_pool = {}
+        return cls._instance
+
+    def create_browser(self, user_agent: str = None) -> Tuple[int, ChromiumPage]:
+        """创建新的浏览器实例"""
+        random_port = random.randint(9223, 9934)
+        while random_port in self.browser_pool:
+            random_port = random.randint(9223, 9934)
+
+        co = ChromiumOptions().set_local_port(random_port)
+        if user_agent:
+            co.set_user_agent(user_agent)
+        if platform.system() != 'Windows':
+            co.set_argument('--no-sandbox')
+        custom_data_dir = os.path.join(os.path.expanduser('~'), 'DrissionPage', "userData", f"{random_port}")
+        co.set_user_data_path(custom_data_dir)  # 设置用户数据路径
+        # if not os.path.exists(custom_data_dir):
+        #     os.makedirs(custom_data_dir)
+        self.browser_pool[random_port] = ChromiumPage(co)
+        return random_port, self.browser_pool[random_port]
+
+    def get_browser(self, port: int) -> Optional[ChromiumPage]:
+        """根据端口获取浏览器实例"""
+        return self.browser_pool.get(port)
+
+    def remove_browser(self, port: int) -> Tuple[bool, Optional[ChromiumPage]]:
+        """根据端口移除浏览器实例"""
+        browser = self.browser_pool.pop(port, None)
+        return browser is not None, browser
+
+    def list_browsers(self) -> list[int]:
+        """列出所有活跃的浏览器端口"""
+        return list(self.browser_pool.keys())
+
+
+# 创建全局单例实例
+browser_manager = BrowserManager()