Jarvis-Brain 0.1.4__py3-none-any.whl

jarvis_brain-0.1.4.dist-info/METADATA

@@ -0,0 +1,12 @@
+Metadata-Version: 2.4
+Name: Jarvis_Brain
+Version: 0.1.4
+Summary: Jarvis brain
+Requires-Python: >=3.10
+Requires-Dist: beautifulsoup4
+Requires-Dist: curl-cffi
+Requires-Dist: drissionpage
+Requires-Dist: fastmcp
+Requires-Dist: htmlmin
+Requires-Dist: jieba
+Requires-Dist: simhash

jarvis_brain-0.1.4.dist-info/RECORD

@@ -0,0 +1,10 @@
+mcp_tools/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+mcp_tools/dp_tools.py,sha256=PwLd1zTFIQ673-cZjdON4TfU854_h5BgLPOVRbt_kVw,8349
+mcp_tools/main.py,sha256=WO9kNpIORRrIOAWW8jiAd3gNW6rFMExln8y4CquKrM8,837
+tools/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+tools/browser_manager.py,sha256=AM9hIQKtgMVxIZsEPxfHj9q41ZtzHrOS69wtgGBE3-Q,1458
+tools/tools.py,sha256=3vTMCT_h0eDPtOMHc2KnhNVpQBUs6jgIChutBZZFMK4,5008
+jarvis_brain-0.1.4.dist-info/METADATA,sha256=CPa_sjNrcHRhHvOXryp09mbbgIW3EY0AP_fT0PKCoNM,275
+jarvis_brain-0.1.4.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+jarvis_brain-0.1.4.dist-info/entry_points.txt,sha256=YFQT4xpkUqt5dM5wlKPQQOqcjMuFrT9iuRAzIpAyH7U,51
+jarvis_brain-0.1.4.dist-info/RECORD,,

jarvis_brain-0.1.4.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.28.0
+Root-Is-Purelib: true
+Tag: py3-none-any

jarvis_brain-0.1.4.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+jarvis-mcp = mcp_tools.main:main

mcp_tools/dp_tools.py

@@ -0,0 +1,169 @@
+import os
+from typing import Any
+
+from DrissionPage._elements.none_element import NoneElement
+from fastmcp import FastMCP
+
+from tools.tools import compress_html, requests_html, dp_headless_html, assert_waf_cookie, dp_mcp_message_pack
+import psutil
+from pathlib import Path
+
+html_source_code_local_save_path = os.path.join(os.getcwd(), "html-source-code")
+waf_status_code_dict = {
+    412: "瑞数",
+    521: "加速乐"
+}
+
+
+def register_visit_url(mcp: FastMCP, browser_manager):
+    @mcp.tool(name="visit_url", description="使用Drissionpage打开url访问某个网站")
+    async def visit_url(url: str) -> dict[str, Any]:
+        port, _browser = browser_manager.create_browser()
+        tab = _browser.get_tab()
+        tab.get(url)
+        tab_id = tab.tab_id
+        return dp_mcp_message_pack(
+            f"已在[{port}]端口创建浏览器对象，并已打开链接：{url}",
+            tab_id=tab_id,
+            browser_port=port
+        )
+
+
+def register_get_html(mcp: FastMCP, browser_manager):
+    @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 = tab.title + f"_{tab_id}.html"
+        if not os.path.exists(html_source_code_local_save_path):
+            os.makedirs(html_source_code_local_save_path)
+        abs_path = os.path.join(html_source_code_local_save_path, file_name)
+        with open(abs_path, "w", encoding="utf-8") as f:
+            min_html, compress_rate = compress_html(tab.html)
+            f.write(min_html)
+        return dp_mcp_message_pack(f"已保存tab页：【{tab_id}】的html源码", tab_id=tab_id, html_local_path=abs_path)
+
+
+def register_get_new_tab(mcp: FastMCP, browser_manager):
+    @mcp.tool(name="get_new_tab", description="使用Drissionpage创建一个新的tab页，在新的tab页中打开url")
+    async def get_new_tab(browser_port: int, url: str) -> dict[str, Any]:
+        _browser = browser_manager.get_browser(browser_port)
+        tab = _browser.new_tab(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):
+    @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):
+    @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):
+    @mcp.tool(name="check_selector", description="查找tab页中是否包含某个元素")
+    async def check_selector(browser_port: int, tab_id: str, css_selector: str) -> 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_ele = target_tab.ele(css_selector)
+        return dp_mcp_message_pack(
+            f"已完成tab页:【{tab_id}】对：【{css_selector}】的检查",
+            tab_id=tab_id,
+            selector=css_selector,
+            selector_ele_exist=not isinstance(target_ele, NoneElement)
+        )
+
+
+def register_quit_browser(mcp: FastMCP, browser_manager):
+    @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_assert_waf(mcp: FastMCP, browser_manager):
+    @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
+        )
+
+
+def register_highlight_element_captcha(mcp: FastMCP, browser_manager):
+    @mcp.tool(name="highlight_element_captcha",
+              description="将传入的Selector在页面上高亮，并截屏")
+    async def highlight_element_captcha(browser_port: int, tab_id: str, selector: str) -> dict[str, Any]:
+        _browser = browser_manager.get_browser(browser_port)
+        tab = _browser.get_tab(tab_id)
+        tab.ele
+
+
+def register_test(mcp: FastMCP, cwd: str):
+    @mcp.tool(name="test", description="用户说要进行测试时调用这个函数")
+    async def test() -> dict[str, Any]:
+        test_project = "获取根目录"
+        return dp_mcp_message_pack(
+            f"当前测试项目是：{test_project}",
+            result=cwd
+        )

mcp_tools/main.py

@@ -0,0 +1,30 @@
+# main.py
+from mcp_tools.dp_tools import *
+from fastmcp import FastMCP
+from tools.browser_manager import browser_manager
+
+mcp = FastMCP("Jarvis Brain Mcp Tools")
+
+# 根据环境变量加载模块
+enabled_modules = os.getenv("MCP_MODULES", "TeamNode-Dp").split(",")
+base_cwd = os.getenv("BASE_CWD", os.environ.get("PWD"))
+
+if "TeamNode-Dp" in enabled_modules:
+    register_visit_url(mcp, browser_manager)
+    register_close_tab(mcp, browser_manager)
+    register_switch_tab(mcp, browser_manager)
+    register_get_html(mcp, browser_manager)
+    register_get_new_tab(mcp, browser_manager)
+    register_check_selector(mcp, browser_manager)
+
+if "JarvisNode" in enabled_modules:
+    register_assert_waf(mcp, browser_manager)
+    register_test(mcp, base_cwd)
+
+
+def main():
+    mcp.run(transport="stdio")
+
+
+if __name__ == '__main__':
+    main()

tools/browser_manager.py

@@ -0,0 +1,42 @@
+"""浏览器池管理模块 - 单例模式确保状态共享"""
+import random
+from DrissionPage import ChromiumPage, ChromiumOptions
+from typing import Optional, Tuple
+
+
+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) -> 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)
+        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()

tools/tools.py

@@ -0,0 +1,119 @@
+import time
+import json
+
+import htmlmin
+from curl_cffi import requests
+from lxml import html, etree
+from bs4 import BeautifulSoup
+from DrissionPage import ChromiumPage, ChromiumOptions
+
+
+# 传入requests的set-cookie的str，返回一个cookie dict
+def cookie_str2dict(cookie_str: str):
+    if cookie_str == "":
+        return {}
+    cookie_dict = {}
+    cookie_list = [cookie.split(";")[0] for cookie in cookie_str.split("HttpOnly,")]
+    for cookie in cookie_list:
+        key, value = cookie.split("=")
+        cookie_dict[key] = value
+    return cookie_dict
+
+
+# 使用requests获取html，用于测试是否使用了瑞数和jsl
+def requests_html(url):
+    headers = {
+        "User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/142.0.0.0 Safari/537.36",
+    }
+    response = requests.get(url, headers=headers, verify=False)
+    # print("response headers=> ", type(response.headers.get("Set-Cookie")),
+    #       cookie_str2dict(response.headers.get("Set-Cookie", "")))
+    response.encoding = "utf-8"
+    return response.text, response.status_code
+
+
+# 使用dp无头模式获取html，用于测试是否使用了其他waf，如移动waf
+def dp_headless_html(url):
+    opt = ChromiumOptions().headless(True)
+    opt.set_argument('--no-sandbox')
+    # 随机端口，固定9222端口的话，可能会被瑞数检测到
+    opt.auto_port()
+    page = ChromiumPage(opt)
+    tab = page.latest_tab
+    tab.get(url)
+    # todo: 目前没有更好的方式，为了数据渲染完全，只能硬等【受网速波动影响比较大】
+    time.sleep(10)
+    page_html = tab.html
+    # 无头浏览器在用完之后一定要记得再page级别进行quit
+    page.quit()
+    return page_html
+
+
+# 压缩html
+def compress_html(content, only_text=False):
+    doc = html.fromstring(content)
+    # 删除 style 和 script 标签
+    for element in doc.xpath('//style | //script'):
+        element.getparent().remove(element)
+
+    # 删除 link 标签
+    for link in doc.xpath('//link[@rel="stylesheet"]'):
+        link.getparent().remove(link)
+
+    # 删除 meta 标签（新增功能）
+    for meta in doc.xpath('//meta'):
+        meta.getparent().remove(meta)
+
+    # 删除 style 属性
+    for element in doc.xpath('//*[@style]'):
+        element.attrib.pop('style')
+
+    # 删除所有 on* 事件属性
+    for element in doc.xpath('//*'):
+        for attr in list(element.attrib.keys()):
+            if attr.startswith('on'):
+                element.attrib.pop(attr)
+
+    result = etree.tostring(doc, encoding='unicode')
+    result = htmlmin.minify(result)
+    compress_rate = round(len(content) / len(result) * 100)
+    print(f"html压缩比=> {compress_rate}%")
+    if not only_text:
+        return result, compress_rate
+    soup = BeautifulSoup(result, 'html.parser')
+    result = soup.get_text(strip=True)
+    return result, compress_rate
+
+
+# 通过cookie判断是否有waf，需要通过遇到的例子，不断的完善cookie判别函数
+def assert_waf_cookie(cookies: list):
+    for cookie in cookies:
+        cookie_name = cookie['name']
+        cookie_value = cookie['value']
+        if len(cookie_name) == 13 and len(cookie_value) == 88:
+            return True, "瑞数"
+        if "_jsl" in cookie_name:
+            return True, "加速乐"
+    return False, "没有waf"
+
+
+# 对dp_mcp的消息打包
+def dp_mcp_message_pack(message: str, **kwargs):
+    text_obj = {key: value for key, value in kwargs.items()}
+    text_obj.update({"message": message})
+    return {
+        "content": [{
+            "type": "text",
+            # "text": json.dumps(text_obj, ensure_ascii=False)
+            "text": text_obj
+        }]
+    }
+
+# todo: 大致盘一下各种判定的逻辑【以下的所有压缩比之间的差距均取“绝对值”】
+#  1. 如果requests、无头、有头获取到的压缩比之间从差距都在15%以内，则认定该页面是静态页面，此时优先使用requests请求
+#  2. 如果requests的status_code为特定的412，或者521，则判定是瑞数和jsl。[此时还有一个特点：requests的压缩比会与其他两种方式获取到的压缩比差距非常大(一两千的那种)]
+#  3. 如果requests、无头、有头获取到的压缩比之间差距都在40%以上，则判定该页面只可以用有头采集
+#  4. 如果无头和有头获取到的压缩比之间差距小于15%，但是requests和无头的差距大于40%，则认定该页面可以使用无头浏览器采集
+#  5. 如果requests和有头获取到的压缩比之间差距小于15%，但是无头和有头的差距大于40%，则认定该页面优先使用有头浏览器采集
+#  【此时可能是：1.使用了别的检测无头的waf。2.网站使用瑞数，但是这次请求没有拦截requests（不知道是不是瑞数那边故意设置的），
+#   此时如果想进一步判定是否是瑞数，可以使用有头浏览器取一下cookies，如果cookies里面存在瑞数的cookie，那么就可以断定是瑞数】