Jarvis-Brain 0.1.9.1__tar.gz → 0.1.9.3__tar.gz

{jarvis_brain-0.1.9.1 → jarvis_brain-0.1.9.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: Jarvis_Brain
-Version: 0.1.9.1
+Version: 0.1.9.3
 Summary: Jarvis brain mcp
 Requires-Python: >=3.10
 Requires-Dist: beautifulsoup4

{jarvis_brain-0.1.9.1 → jarvis_brain-0.1.9.3}/mcp_tools/dp_tools.py

@@ -20,14 +20,22 @@ 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]:
+              description="使用Drissionpage打开url访问某个网站，并开始监听初始tab页的所有的XHR请求"
+                          "当需要使用手机版浏览器Ua时use_mobile_user_agent为True"
+                          "如果想要以域名对packet进行过滤，可以传入想要过滤的域名列表。默认是：None。"
+                          "如果想要以method对packet进行过滤，可以传入想要过滤的method列表，默认是：['GET', 'POST']")
+    async def visit_url(url: str, domain_filter: list = None, method_filter: list = ["GET", "POST"],
+                        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)
+        packet_filter = {
+            "domain_filter": domain_filter,
+            "method_filter": method_filter,
+        }
+        client_manager.create_client(tab, packet_filter)
         tab.get(url)
         tab_id = tab.tab_id
         return dp_mcp_message_pack(
@@ -39,11 +47,18 @@ def register_visit_url(mcp: FastMCP, browser_manager: BrowserManager, client_man
 
 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]:
+              description="使用Drissionpage创建一个新的tab页，在新的tab页中打开url，并开始监听新的tab页的所有XHR请求"
+                          "如果想要以域名对packet进行过滤，可以传入想要过滤的域名列表。默认是：None。"
+                          "如果想要以method对packet进行过滤，可以传入想要过滤的method列表，默认是：['GET', 'POST']")
+    async def get_new_tab(browser_port: int, url: str, domain_filter: list = None,
+                          method_filter: list = ["GET", "POST"]) -> dict[str, Any]:
         _browser = browser_manager.get_browser(browser_port)
         tab = _browser.new_tab()
-        client_manager.create_client(tab)
+        packet_filter = {
+            "domain_filter": domain_filter,
+            "method_filter": method_filter,
+        }
+        client_manager.create_client(tab, packet_filter)
         tab.get(url)
         _browser.activate_tab(tab)
         tab_id = tab.tab_id
@@ -52,20 +67,22 @@ def register_get_new_tab(mcp: FastMCP, browser_manager, client_manager: DPProxyC
 
 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字段"
-                          "同时如果想要以域名对packet进行过滤，可以传入想要过滤的域名列表。")
-    async def pop_first_packet(browser_port: int, tab_id: str, domain_filter: list = None) -> dict[str, Any]:
+              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(domain_filter)
+        current_queue_size, packet_message = client.pop_first_packet()
         message = f"tab页:【{tab_id}】，暂时没有监听到XHR数据包"
         if packet_message:
-            message = f"tab页:【{tab_id}】，监听到XHR数据包",
+            message = f"tab页:【{tab_id}】，监听到XHR数据包，当前数据包队列中还剩 {current_queue_size} 条数据"
+        if current_queue_size:
+            message = f"tab页:【{tab_id}】，当前弹出的第一个数据包不符合过滤条件，当前数据包队列中还剩 {current_queue_size} 条数据，请不要改变条件，继续弹出下一个数据包"
         return dp_mcp_message_pack(
             message,
             browser_port=browser_port,
             tab_id=tab_id,
-            packet_message=packet_message
+            packet_message=packet_message,
+            current_queue_size=current_queue_size,
         )
 
 

{jarvis_brain-0.1.9.1 → jarvis_brain-0.1.9.3}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "Jarvis_Brain"  # 别人下载时用的名字，必须在 PyPI 上唯一
-version = "0.1.9.1"
+version = "0.1.9.3"
 description = "Jarvis brain mcp"
 dependencies = [
     "fastmcp",

{jarvis_brain-0.1.9.1 → jarvis_brain-0.1.9.3}/tools/browser_proxy.py

@@ -12,12 +12,12 @@ one_turn_max_token = 20000
 
 
 class DPProxyClient:
-    def __init__(self, driver: ChromiumTab, self_kill=False):
+    def __init__(self, driver: ChromiumTab, packet_filter: dict, self_kill=False):
         self.tab_id = driver.tab_id
         self.driver = ChromePageProxy(driver, self)
         self.thread = None
         self.self_kill = self_kill
-        # self.packet_list = []
+        self.packet_filter = packet_filter
         self.packet_queue = deque()
 
     def get_driver(self, start_listen, count=None, timeout=10) -> ChromiumTab:
@@ -40,20 +40,13 @@ class DPProxyClient:
             pass
 
     # 每次调用函数，都从队列的左端弹出一个数据包
-    def pop_first_packet(self, domain_filter: list):
+    def pop_first_packet(self):
         if self.packet_queue:
             result = self.packet_queue.popleft()
-            packet_url = result["url"]
-            packet_domain = urlparse(packet_url).netloc
-            # 留两个路径和params的口子，万一后续需要加入这两个的过滤器可以参考domain过滤器的方式
-            packet_path = urlparse(packet_url).path
-            packet_param = urlparse(packet_url).params
-            # 如果没有给domain_filter或者给了domain_filter且包的domain在domain_filter中，都正常返回
-            if domain_filter is None or (domain_filter and packet_domain in domain_filter):
-                return json.dumps(result, ensure_ascii=False)
-            return None
+            current_queue_size = len(self.packet_queue)
+            return current_queue_size, json.dumps(result, ensure_ascii=False)
         else:
-            return None
+            return 0, None
 
 
 class DPProxyClientManager:
@@ -66,9 +59,10 @@ class DPProxyClientManager:
             cls._instance.tab_pool = {}
         return cls._instance
 
-    def create_client(self, tab: ChromiumTab, self_kill=False) -> Tuple[str, DPProxyClient, ChromiumTab]:
+    def create_client(self, tab: ChromiumTab, packet_filter: dict, self_kill=False) -> Tuple[
+        str, DPProxyClient, ChromiumTab]:
         """创建新的tab页面代理实例"""
-        client = DPProxyClient(tab, self_kill=self_kill)
+        client = DPProxyClient(tab, packet_filter, self_kill=self_kill)
         tab = client.get_driver(True, timeout=60 * 10)
         tab_id = tab.tab_id
         self.tab_pool[tab_id] = {"client": client, "driver": tab}
@@ -144,11 +138,21 @@ def check_data_packet(packet: DataPacket, client: DPProxyClient):
     data = None
     if packet.request.hasPostData:
         data = packet.request.postData
+    domain = urlparse(url).netloc
     body = packet.response.body
     body_str = json.dumps(body, ensure_ascii=False)
     body_str_list = [body_str[i:i + one_turn_max_token] for i in range(0, len(body_str), one_turn_max_token)]
     body_completed = True
+    packet_filter = client.packet_filter
+    domain_filter = packet_filter.get("domain_filter", None)
+    method_filter = packet_filter.get("method_filter", ["GET", "POST"])
     for index, body_str in enumerate(body_str_list):
+        # 如果给了domain_filter并且domain没有在domain_filter中时跳过该数据包
+        if domain_filter and domain not in domain_filter:
+            continue
+        # 如果method没有在method_filter中，则跳过该数据包
+        if method not in method_filter:
+            continue
         if (index + 1) != len(body_str_list):
             body_completed = False
         temp_dict = {