mobile-mcp-ai 2.7.0__py3-none-any.whl → 2.7.4__py3-none-any.whl

mobile_mcp/core/basic_tools_lite.py

@@ -158,6 +158,33 @@ class BasicMobileToolsLite:
                 return info.get('package')
         except Exception:
             return None
+
+    def _normalize_resource_id(self, resource_id: str) -> str:
+        """标准化 resource-id，支持前端只传简写 id 时自动补全包名
+
+        约定：
+        - Android:
+            - 如果传入的是完整 id（包含 ':' 或 '/'），直接返回
+            - 如果是简写（如 'qylt_search_input_layout'），自动补全为
+              '{package}:id/{resource_id}'，package 优先使用 target_package，
+              否则使用当前前台应用包名
+        - iOS: 直接原样返回
+        """
+        # iOS 不做处理，保持与 WDA 一致
+        if self._is_ios():
+            return resource_id
+
+        # 已经是完整 id 或者包含路径信息时，不再修改
+        if ":" in resource_id or "/" in resource_id:
+            return resource_id
+
+        # 尝试获取包名：优先使用目标应用包名，其次当前前台应用
+        package = getattr(self, "target_package", None) or self._get_current_package()
+        if not package:
+            # 没有包名信息时，回退为原值，避免误拼接错误包名
+            return resource_id
+
+        return f"{package}:id/{resource_id}"
     
     def _check_app_switched(self) -> Dict:
         """检查是否已跳出目标应用
@@ -1286,13 +1313,13 @@ class BasicMobileToolsLite:
                         page_texts = self._get_page_texts(10)
                         return {"success": True, "page_texts": page_texts}
                     
-                    # 选择器失败，用坐标兜底
+                    # 选择器失败，用控件中心坐标点兜底
                     if bounds:
                         x = (bounds[0] + bounds[2]) // 2
                         y = (bounds[1] + bounds[3]) // 2
                         self.client.u2.click(x, y)
                         time.sleep(0.3)
-                        self._record_click('percent', f"{x_pct}%,{y_pct}%", x_pct, y_pct,
+                        self._record_click('coords', f"{x},{y}", x_pct, y_pct,
                                           element_desc=text)
                         # 验证逻辑
                         if verify:
@@ -1346,12 +1373,14 @@ class BasicMobileToolsLite:
         except Exception as e:
             return {"success": True, "verified": False, "hint": f"验证异常: {e}"}
     
-    def _find_element_in_tree(self, text: str, position: Optional[str] = None) -> Optional[Dict]:
-        """在 XML 树中查找包含指定文本的元素，优先返回可点击的元素
+    def _find_element_in_tree(self, text: str, position: Optional[str] = None, exact_match: bool = True) -> Optional[Dict]:
+        """在 XML 树中查找指定文本的元素，优先返回可点击的元素
         
         Args:
             text: 要查找的文本
             position: 位置信息，用于在有多个相同文案时筛选
+            exact_match: 是否精确匹配。True=优先精确匹配（用于定位元素如点击），
+                        False=只进行包含匹配（用于验证元素）
         """
         try:
             xml = self.client.u2.dump_hierarchy(compressed=False)
@@ -1383,26 +1412,40 @@ class BasicMobileToolsLite:
                 attr_type = None
                 attr_value = None
                 
-                # 精确匹配 text
-                if elem_text == text:
-                    is_match = True
-                    attr_type = 'text'
-                    attr_value = text
-                # 精确匹配 content-desc
-                elif elem_desc == text:
-                    is_match = True
-                    attr_type = 'description'
-                    attr_value = text
-                # 模糊匹配 text
-                elif text in elem_text:
-                    is_match = True
-                    attr_type = 'textContains'
-                    attr_value = text
-                # 模糊匹配 content-desc
-                elif text in elem_desc:
-                    is_match = True
-                    attr_type = 'descriptionContains'
-                    attr_value = text
+                if exact_match:
+                    # 精确匹配模式（用于定位元素）：优先精确匹配
+                    # 精确匹配 text
+                    if elem_text == text:
+                        is_match = True
+                        attr_type = 'text'
+                        attr_value = text
+                    # 精确匹配 content-desc
+                    elif elem_desc == text:
+                        is_match = True
+                        attr_type = 'description'
+                        attr_value = text
+                    # 精确匹配找不到时，再尝试包含匹配（作为兜底）
+                    elif text in elem_text:
+                        is_match = True
+                        attr_type = 'textContains'
+                        attr_value = text
+                    # 包含匹配 content-desc
+                    elif text in elem_desc:
+                        is_match = True
+                        attr_type = 'descriptionContains'
+                        attr_value = text
+                else:
+                    # 包含匹配模式（用于验证元素）：只进行包含匹配
+                    # 包含匹配 text
+                    if text in elem_text:
+                        is_match = True
+                        attr_type = 'textContains'
+                        attr_value = text
+                    # 包含匹配 content-desc
+                    elif text in elem_desc:
+                        is_match = True
+                        attr_type = 'descriptionContains'
+                        attr_value = text
                 
                 if is_match and bounds:
                     # 计算元素的中心点坐标
@@ -1421,6 +1464,17 @@ class BasicMobileToolsLite:
             if not matched_elements:
                 return None
             
+            # 精确匹配模式下，优先返回精确匹配的元素（text/description），再返回包含匹配的元素
+            if exact_match:
+                exact_matches = [m for m in matched_elements if m['attr_type'] in ['text', 'description']]
+                contains_matches = [m for m in matched_elements if m['attr_type'] in ['textContains', 'descriptionContains']]
+                # 如果有精确匹配，优先使用精确匹配的结果
+                if exact_matches:
+                    matched_elements = exact_matches + contains_matches
+                # 如果没有精确匹配，使用包含匹配的结果
+                else:
+                    matched_elements = contains_matches
+            
             # 如果有位置信息，根据位置筛选
             if position and len(matched_elements) > 1:
                 position_lower = position.lower()
@@ -1459,6 +1513,7 @@ class BasicMobileToolsLite:
                 }
             
             # 没有位置信息时，优先返回可点击的元素
+            # 由于前面已经排序（精确匹配在前），这里会优先返回精确匹配且可点击的元素
             for match in matched_elements:
                 if match['clickable']:
                     return {
@@ -1504,17 +1559,23 @@ class BasicMobileToolsLite:
                 else:
                     return {"success": False, "msg": "iOS未初始化"}
             else:
-                elem = self.client.u2(resourceId=resource_id)
+                normalized_id = self._normalize_resource_id(resource_id)
+                elem = self.client.u2(resourceId=normalized_id)
                 if elem.exists(timeout=0.5):
                     count = elem.count
                     if index < count:
                         elem[index].click()
                         time.sleep(0.3)
-                        self._record_click('id', resource_id, element_desc=resource_id)
+                        # 记录时同时保留原始入参和实际使用的 id 信息
+                        self._record_click('id', normalized_id, element_desc=resource_id)
                         return {"success": True}
                     else:
                         return {"success": False, "msg": f"索引{index}超出范围(共{count}个)"}
-                return {"success": False, "fallback": "vision", "msg": f"未找到ID'{resource_id}'"}
+                return {
+                    "success": False,
+                    "fallback": "vision",
+                    "msg": f"未找到ID'{resource_id}' (实际匹配: '{normalized_id}')"
+                }
         except Exception as e:
             return {"success": False, "msg": str(e)}
     
@@ -1777,13 +1838,20 @@ class BasicMobileToolsLite:
                         return {"success": True}
                     return {"success": False, "msg": f"未找到'{resource_id}'"}
             else:
-                elem = self.client.u2(resourceId=resource_id)
+                normalized_id = self._normalize_resource_id(resource_id)
+                elem = self.client.u2(resourceId=normalized_id)
                 if elem.exists(timeout=0.5):
                     elem.long_click(duration=duration)
                     time.sleep(0.3)
-                    self._record_long_press('id', resource_id, duration, element_desc=resource_id)
-                    return {"success": True, "message": f"✅ 长按成功: {resource_id} 持续 {duration}s"}
-                return {"success": False, "msg": f"未找到'{resource_id}'"}
+                    self._record_long_press('id', normalized_id, duration, element_desc=resource_id)
+                    return {
+                        "success": True,
+                        "message": f"✅ 长按成功: {resource_id} (实际匹配: {normalized_id}) 持续 {duration}s"
+                    }
+                return {
+                    "success": False,
+                    "msg": f"未找到'{resource_id}' (实际匹配: '{normalized_id}')"
+                }
         except Exception as e:
             return {"success": False, "message": f"❌ 长按失败: {e}"}
     
@@ -1833,7 +1901,8 @@ class BasicMobileToolsLite:
                         }
                     return {"success": False, "message": f"❌ 输入框不存在: {resource_id}"}
             else:
-                elements = self.client.u2(resourceId=resource_id)
+                normalized_id = self._normalize_resource_id(resource_id)
+                elements = self.client.u2(resourceId=normalized_id)
                 
                 # 检查是否存在
                 if elements.exists(timeout=0.5):
@@ -1843,7 +1912,7 @@ class BasicMobileToolsLite:
                     if count == 1:
                         elements.set_text(text)
                         time.sleep(0.3)
-                        self._record_input(text, 'id', resource_id)
+                        self._record_input(text, 'id', normalized_id)
                         
                         # 🎯 关键步骤：检查应用是否跳转，如果跳转则自动返回目标应用
                         app_check = self._check_app_switched()
@@ -1851,7 +1920,7 @@ class BasicMobileToolsLite:
                         if app_check['switched']:
                             return_result = self._return_to_target_app()
                         
-                        msg = f"✅ 输入成功: '{text}'"
+                        msg = f"✅ 输入成功: '{text}' (id: {resource_id}, 实际匹配: {normalized_id})"
                         if app_check['switched']:
                             msg += f"\n{app_check['message']}"
                             if return_result:
@@ -2071,13 +2140,16 @@ class BasicMobileToolsLite:
     
     # ==================== 导航操作 ====================
     
-    async def swipe(self, direction: str, y: Optional[int] = None, y_percent: Optional[float] = None) -> Dict:
+    async def swipe(self, direction: str, y: Optional[int] = None, y_percent: Optional[float] = None,
+                   distance: Optional[int] = None, distance_percent: Optional[float] = None) -> Dict:
         """滑动屏幕
         
         Args:
             direction: 滑动方向 (up/down/left/right)
             y: 左右滑动时指定的高度坐标（像素）
             y_percent: 左右滑动时指定的高度百分比 (0-100)
+            distance: 横向滑动时指定的滑动距离（像素），仅用于 left/right
+            distance_percent: 横向滑动时指定的滑动距离百分比 (0-100)，仅用于 left/right
         """
         try:
             if self._is_ios():
@@ -2104,20 +2176,53 @@ class BasicMobileToolsLite:
                     swipe_y = y
                 else:
                     swipe_y = center_y
+                
+                # 计算横向滑动距离
+                if distance_percent is not None:
+                    if not (0 <= distance_percent <= 100):
+                        return {"success": False, "message": f"❌ distance_percent 必须在 0-100 之间: {distance_percent}"}
+                    swipe_distance = int(width * distance_percent / 100)
+                elif distance is not None:
+                    if distance <= 0:
+                        return {"success": False, "message": f"❌ distance 必须大于 0: {distance}"}
+                    if distance > width:
+                        return {"success": False, "message": f"❌ distance 不能超过屏幕宽度 ({width}): {distance}"}
+                    swipe_distance = distance
+                else:
+                    # 默认滑动距离：屏幕宽度的 60%（从 0.8 到 0.2）
+                    swipe_distance = int(width * 0.6)
+                
+                # 计算起始和结束位置
+                if direction == 'left':
+                    # 从右向左滑动：起始点在右侧，结束点在左侧
+                    # 确保起始点不超出屏幕右边界
+                    start_x = min(center_x + swipe_distance // 2, width - 10)
+                    end_x = start_x - swipe_distance
+                    # 确保结束点不超出屏幕左边界
+                    if end_x < 10:
+                        end_x = 10
+                        start_x = min(end_x + swipe_distance, width - 10)
+                else:  # right
+                    # 从左向右滑动：起始点在左侧，结束点在右侧
+                    # 确保起始点不超出屏幕左边界
+                    start_x = max(center_x - swipe_distance // 2, 10)
+                    end_x = start_x + swipe_distance
+                    # 确保结束点不超出屏幕右边界
+                    if end_x > width - 10:
+                        end_x = width - 10
+                        start_x = max(end_x - swipe_distance, 10)
+                
+                x1, y1, x2, y2 = start_x, swipe_y, end_x, swipe_y
             else:
                 swipe_y = center_y
-            
-            swipe_map = {
-                'up': (center_x, int(height * 0.8), center_x, int(height * 0.2)),
-                'down': (center_x, int(height * 0.2), center_x, int(height * 0.8)),
-                'left': (int(width * 0.8), swipe_y, int(width * 0.2), swipe_y),
-                'right': (int(width * 0.2), swipe_y, int(width * 0.8), swipe_y),
-            }
-            
-            if direction not in swipe_map:
-                return {"success": False, "message": f"❌ 不支持的方向: {direction}"}
-            
-            x1, y1, x2, y2 = swipe_map[direction]
+                # 纵向滑动保持原有逻辑
+                swipe_map = {
+                    'up': (center_x, int(height * 0.8), center_x, int(height * 0.2)),
+                    'down': (center_x, int(height * 0.2), center_x, int(height * 0.8)),
+                }
+                if direction not in swipe_map:
+                    return {"success": False, "message": f"❌ 不支持的方向: {direction}"}
+                x1, y1, x2, y2 = swipe_map[direction]
             
             if self._is_ios():
                 ios_client.wda.swipe(x1, y1, x2, y2)
@@ -2138,10 +2243,21 @@ class BasicMobileToolsLite:
             # 构建返回消息
             msg = f"✅ 滑动成功: {direction}"
             if direction in ['left', 'right']:
+                msg_parts = []
                 if y_percent is not None:
-                    msg += f" (高度: {y_percent}% = {swipe_y}px)"
+                    msg_parts.append(f"高度: {y_percent}% = {swipe_y}px")
                 elif y is not None:
-                    msg += f" (高度: {y}px)"
+                    msg_parts.append(f"高度: {y}px")
+                
+                if distance_percent is not None:
+                    msg_parts.append(f"距离: {distance_percent}% = {swipe_distance}px")
+                elif distance is not None:
+                    msg_parts.append(f"距离: {distance}px")
+                else:
+                    msg_parts.append(f"距离: 默认 {swipe_distance}px")
+                
+                if msg_parts:
+                    msg += f" ({', '.join(msg_parts)})"
             
             # 如果检测到应用跳转，添加警告和返回结果
             if app_check['switched']:
@@ -2206,6 +2322,170 @@ class BasicMobileToolsLite:
         self.operation_history.append(record)
         return {"success": True}
     
+    async def drag_progress_bar(self, direction: str = "right", distance_percent: float = 30.0, 
+                                y_percent: Optional[float] = None, y: Optional[int] = None) -> Dict:
+        """智能拖动进度条
+        
+        自动检测进度条是否可见：
+        - 如果进度条已显示，直接拖动（无需先点击播放区域）
+        - 如果进度条未显示，先点击播放区域显示控制栏，再拖动
+        
+        Args:
+            direction: 拖动方向，'left'（倒退）或 'right'（前进），默认 'right'
+            distance_percent: 拖动距离百分比 (0-100)，默认 30%
+            y_percent: 进度条的垂直位置百分比 (0-100)，如果未指定则自动检测
+            y: 进度条的垂直位置坐标（像素），如果未指定则自动检测
+        """
+        try:
+            import xml.etree.ElementTree as ET
+            import re
+            
+            if self._is_ios():
+                return {"success": False, "message": "❌ iOS 暂不支持，请使用 mobile_swipe"}
+            
+            if direction not in ['left', 'right']:
+                return {"success": False, "message": f"❌ 拖动方向必须是 'left' 或 'right': {direction}"}
+            
+            screen_width, screen_height = self.client.u2.window_size()
+            
+            # 获取 XML 查找进度条
+            xml_string = self.client.u2.dump_hierarchy(compressed=False)
+            root = ET.fromstring(xml_string)
+            
+            progress_bar_found = False
+            progress_bar_y = None
+            progress_bar_y_percent = None
+            
+            # 查找进度条元素（SeekBar、ProgressBar）
+            for elem in root.iter():
+                class_name = elem.attrib.get('class', '')
+                resource_id = elem.attrib.get('resource-id', '')
+                bounds_str = elem.attrib.get('bounds', '')
+                
+                # 检查是否是进度条
+                is_progress_bar = (
+                    'SeekBar' in class_name or 
+                    'ProgressBar' in class_name or
+                    'progress' in resource_id.lower() or
+                    'seek' in resource_id.lower()
+                )
+                
+                if is_progress_bar and bounds_str:
+                    # 解析 bounds 获取进度条位置
+                    match = re.match(r'\[(\d+),(\d+)\]\[(\d+),(\d+)\]', bounds_str)
+                    if match:
+                        x1, y1, x2, y2 = map(int, match.groups())
+                        center_y = (y1 + y2) // 2
+                        progress_bar_y = center_y
+                        progress_bar_y_percent = round(center_y / screen_height * 100, 1)
+                        progress_bar_found = True
+                        break
+            
+            # 如果未找到进度条，尝试点击播放区域显示控制栏
+            if not progress_bar_found:
+                # 点击屏幕中心显示控制栏
+                center_x, center_y = screen_width // 2, screen_height // 2
+                self.client.u2.click(center_x, center_y)
+                time.sleep(0.5)
+                
+                # 再次查找进度条
+                xml_string = self.client.u2.dump_hierarchy(compressed=False)
+                root = ET.fromstring(xml_string)
+                
+                for elem in root.iter():
+                    class_name = elem.attrib.get('class', '')
+                    resource_id = elem.attrib.get('resource-id', '')
+                    bounds_str = elem.attrib.get('bounds', '')
+                    
+                    is_progress_bar = (
+                        'SeekBar' in class_name or 
+                        'ProgressBar' in class_name or
+                        'progress' in resource_id.lower() or
+                        'seek' in resource_id.lower()
+                    )
+                    
+                    if is_progress_bar and bounds_str:
+                        match = re.match(r'\[(\d+),(\d+)\]\[(\d+),(\d+)\]', bounds_str)
+                        if match:
+                            x1, y1, x2, y2 = map(int, match.groups())
+                            center_y = (y1 + y2) // 2
+                            progress_bar_y = center_y
+                            progress_bar_y_percent = round(center_y / screen_height * 100, 1)
+                            progress_bar_found = True
+                            break
+            
+            # 确定使用的高度位置
+            if y_percent is not None:
+                swipe_y = int(screen_height * y_percent / 100)
+                used_y_percent = y_percent
+            elif y is not None:
+                swipe_y = y
+                used_y_percent = round(y / screen_height * 100, 1)
+            elif progress_bar_found:
+                swipe_y = progress_bar_y
+                used_y_percent = progress_bar_y_percent
+            else:
+                # 默认使用屏幕底部附近（进度条常见位置）
+                swipe_y = int(screen_height * 0.91)
+                used_y_percent = 91.0
+            
+            # 计算滑动距离
+            swipe_distance = int(screen_width * distance_percent / 100)
+            
+            # 计算起始和结束位置
+            center_x = screen_width // 2
+            if direction == 'left':
+                start_x = min(center_x + swipe_distance // 2, screen_width - 10)
+                end_x = start_x - swipe_distance
+                if end_x < 10:
+                    end_x = 10
+                    start_x = min(end_x + swipe_distance, screen_width - 10)
+            else:  # right
+                start_x = max(center_x - swipe_distance // 2, 10)
+                end_x = start_x + swipe_distance
+                if end_x > screen_width - 10:
+                    end_x = screen_width - 10
+                    start_x = max(end_x - swipe_distance, 10)
+            
+            # 执行拖动
+            self.client.u2.swipe(start_x, swipe_y, end_x, swipe_y, duration=0.5)
+            time.sleep(0.3)
+            
+            # 记录操作
+            self._record_swipe(direction)
+            
+            # 检查应用是否跳转
+            app_check = self._check_app_switched()
+            return_result = None
+            if app_check['switched']:
+                return_result = self._return_to_target_app()
+            
+            # 构建返回消息
+            msg = f"✅ 进度条拖动成功: {direction} (高度: {used_y_percent}%, 距离: {distance_percent}%)"
+            if not progress_bar_found:
+                msg += "\n💡 已自动点击播放区域显示控制栏"
+            else:
+                msg += "\n💡 进度条已显示，直接拖动"
+            
+            if app_check['switched']:
+                msg += f"\n{app_check['message']}"
+                if return_result and return_result.get('success'):
+                    msg += f"\n{return_result['message']}"
+            
+            return {
+                "success": True,
+                "message": msg,
+                "progress_bar_found": progress_bar_found,
+                "y_percent": used_y_percent,
+                "distance_percent": distance_percent,
+                "direction": direction,
+                "app_check": app_check,
+                "return_to_app": return_result
+            }
+            
+        except Exception as e:
+            return {"success": False, "message": f"❌ 拖动进度条失败: {e}"}
+    
     # ==================== 应用管理 ====================
     
     async def launch_app(self, package_name: str) -> Dict:
@@ -2369,6 +2649,26 @@ class BasicMobileToolsLite:
                     'carrier', 'operator', 'sim_', 'mobile_signal'
                 }
                 
+                # 系统控件关键词（厂商系统UI元素，对测试没有意义，直接过滤）
+                SYSTEM_WIDGET_KEYWORDS = {
+                    'system_icon', 'systemicon', 'system_image', 'systemimage',
+                    'vivo_', 'vivo_superx', 'superx', 'super_x',
+                    'miui_', 'miui_system', 'huawei_', 'emui_',
+                    'oppo_', 'coloros_', 'oneplus_', 'realme_',
+                    'samsung_', 'oneui_', 'com.android.systemui',
+                    'system_ui', 'systemui', 'navigation_bar', 'navigationbar'
+                }
+                
+                # 系统弹窗交互文本（如果元素包含这些文本，即使 resource_id 匹配系统控件，也不过滤）
+                # 这些是系统弹窗（权限请求、系统对话框等）的常见按钮文本
+                SYSTEM_DIALOG_INTERACTIVE_TEXTS = {
+                    '允许', '拒绝', '确定', '取消', '同意', '不同意',
+                    '允许访问', '拒绝访问', '始终允许', '仅在使用时允许',
+                    '确定', '取消', '是', '否', '好', '知道了',
+                    'Allow', 'Deny', 'OK', 'Cancel', 'Yes', 'No',
+                    'Accept', 'Reject', 'Grant', 'Deny'
+                }
+                
                 # Token 优化：构建精简元素（只返回非空字段）
                 def build_compact_element(resource_id, text, content_desc, bounds, likely_click, class_name):
                     """只返回有值的字段，节省 token"""
@@ -2412,6 +2712,41 @@ class BasicMobileToolsLite:
                         if any(keyword in resource_id_lower for keyword in STATUS_BAR_KEYWORDS):
                             continue
                     
+                    # 1.6 过滤系统控件（厂商系统UI元素，对测试没有意义）
+                    # 例外：如果元素有明确的交互文本（系统弹窗按钮），不过滤
+                    if resource_id:
+                        resource_id_lower = resource_id.lower()
+                        
+                        # 检查是否是系统弹窗的交互按钮（有明确的交互文本）
+                        is_system_dialog_button = (
+                            text in SYSTEM_DIALOG_INTERACTIVE_TEXTS or
+                            content_desc in SYSTEM_DIALOG_INTERACTIVE_TEXTS
+                        )
+                        
+                        # 特殊处理：android:id/ 开头的元素
+                        if 'android:id/' in resource_id_lower:
+                            # android:id/button1, android:id/button2 等是系统弹窗按钮，应该保留
+                            # 只过滤特定的系统UI容器元素
+                            android_system_ids_to_filter = [
+                                'android:id/statusbarbackground',
+                                'android:id/navigationbarbackground'
+                            ]
+                            # 如果是系统弹窗按钮（有交互文本）或者是按钮类ID，保留
+                            if (is_system_dialog_button or 
+                                'button' in resource_id_lower or
+                                resource_id_lower not in [id.lower() for id in android_system_ids_to_filter]):
+                                # 保留，不过滤
+                                pass
+                            else:
+                                # 过滤系统UI容器
+                                continue
+                        else:
+                            # 非 android:id/ 开头的元素，检查是否匹配系统控件关键词
+                            # 如果是系统弹窗按钮（有交互文本），不过滤
+                            if not is_system_dialog_button:
+                                if any(keyword in resource_id_lower for keyword in SYSTEM_WIDGET_KEYWORDS):
+                                    continue
+                    
                     # 2. 检查是否是功能控件（直接保留）
                     if class_name in FUNCTIONAL_WIDGETS:
                         # 使用启发式判断可点击性（替代不准确的 clickable 属性）
@@ -2754,7 +3089,7 @@ class BasicMobileToolsLite:
         except Exception as e:
             return {"success": False, "msg": str(e)}
     
-    def close_popup(self) -> Dict:
+    def close_popup(self, popup_detected: bool = None, popup_bounds: tuple = None) -> Dict:
         """智能关闭弹窗（改进版）
         
         核心改进：先检测弹窗区域，再在弹窗范围内查找关闭按钮
@@ -2768,6 +3103,10 @@ class BasicMobileToolsLite:
         适配策略：
         - X 按钮可能在任意位置（上下左右都支持）
         - 使用百分比坐标记录，跨分辨率兼容
+        
+        Args:
+            popup_detected: 可选，AI已识别到弹窗时为True，跳过弹窗检测
+            popup_bounds: 可选，弹窗边界 (x1, y1, x2, y2)，如果AI已识别到弹窗区域可传入
         """
         try:
             import re
@@ -2788,25 +3127,40 @@ class BasicMobileToolsLite:
             close_desc_keywords = ['关闭', 'close', 'dismiss', 'cancel', '跳过']
             
             close_candidates = []
-            popup_bounds = None  # 弹窗区域
+            all_clickable_elements = []  # 所有可点击元素（用于兜底策略）
+            popup_confidence = 0.0
             
             # 解析 XML
             try:
                 root = ET.fromstring(xml_string)
                 all_elements = list(root.iter())
                 
-                # ===== 第一步：使用严格的置信度检测弹窗区域 =====
-                popup_bounds, popup_confidence = self._detect_popup_with_confidence(
-                    root, screen_width, screen_height
-                )
-                
-                # 如果置信度不够高，记录但继续尝试查找关闭按钮
-                popup_detected = popup_bounds is not None and popup_confidence >= 0.6
+                # ===== 第一步：检测弹窗区域（如果AI未传入完整弹窗信息）=====
+                if popup_bounds is None:
+                    # 无论popup_detected是否传入，都需要检测bounds来定位弹窗区域
+                    detected_bounds, detected_confidence = self._detect_popup_with_confidence(
+                        root, screen_width, screen_height
+                    )
+                    popup_bounds = detected_bounds
+                    popup_confidence = detected_confidence
+                    
+                    # 如果AI未传入popup_detected，根据检测结果判断
+                    if popup_detected is None:
+                        popup_detected = popup_bounds is not None and popup_confidence >= 0.6
+                    # 如果AI传入了popup_detected=True，但检测不到bounds，仍然使用AI的判断
+                    elif popup_detected and popup_bounds is None:
+                        # AI说有问题但检测不到，可能是检测算法不够准确，信任AI的判断
+                        popup_detected = True
+                        popup_confidence = 0.7  # 降低置信度，因为检测不到bounds
+                else:
+                    # AI已传入popup_bounds，直接使用
+                    if popup_detected is None:
+                        # 有bounds就认为有弹窗
+                        popup_detected = True
+                    popup_confidence = 0.8  # AI识别到的弹窗，置信度较高
                 
-                # 🔴 关键检查：如果没有检测到弹窗区域，直接返回"无弹窗"
-                # 避免误点击普通页面上的"关闭"、"取消"等按钮
-                if not popup_detected:
-                    return {"success": True, "popup": False}
+                # 【重要修复】如果没有检测到弹窗区域，只搜索有明确关闭特征的元素（文本、resource-id等）
+                # 避免误点击普通页面的右上角图标
                 
                 # ===== 第二步：在弹窗范围内查找关闭按钮 =====
                 for idx, elem in enumerate(all_elements):
@@ -2815,6 +3169,7 @@ class BasicMobileToolsLite:
                     bounds_str = elem.attrib.get('bounds', '')
                     class_name = elem.attrib.get('class', '')
                     clickable = elem.attrib.get('clickable', 'false') == 'true'
+                    resource_id = elem.attrib.get('resource-id', '')
                     
                     if not bounds_str:
                         continue
@@ -2830,8 +3185,22 @@ class BasicMobileToolsLite:
                     center_x = (x1 + x2) // 2
                     center_y = (y1 + y2) // 2
                     
+                    # 收集所有可点击元素（用于兜底策略：当只有一个可点击元素时点击它）
+                    if clickable:
+                        all_clickable_elements.append({
+                            'bounds': bounds_str,
+                            'center_x': center_x,
+                            'center_y': center_y,
+                            'width': width,
+                            'height': height,
+                            'text': text,
+                            'content_desc': content_desc,
+                            'resource_id': resource_id,
+                            'class_name': class_name
+                        })
+                    
                     # 如果检测到弹窗区域，检查元素是否在弹窗范围内或附近
-                    in_popup = True
+                    in_popup = False
                     popup_edge_bonus = 0
                     is_floating_close = False  # 是否是浮动关闭按钮（在弹窗外部上方）
                     if popup_bounds:
@@ -2872,6 +3241,20 @@ class BasicMobileToolsLite:
                         # 浮动关闭按钮（在弹窗上方外侧）给予高额加分
                         if is_floating_close:
                             popup_edge_bonus += 5.0  # 大幅加分
+                    elif not popup_detected:
+                        # 没有检测到弹窗时，只处理有明确关闭特征的元素
+                        # 检查是否有明确的关闭特征（文本、resource-id、content-desc）
+                        has_explicit_close_feature = (
+                            text in close_texts or
+                            any(kw in content_desc.lower() for kw in close_desc_keywords) or
+                            'close' in resource_id.lower() or
+                            'dismiss' in resource_id.lower() or
+                            'cancel' in resource_id.lower()
+                        )
+                        if not has_explicit_close_feature:
+                            continue  # 没有明确关闭特征，跳过
+                        # 有明确关闭特征时，允许处理
+                        in_popup = True
                     
                     if not in_popup:
                         continue
@@ -2945,6 +3328,33 @@ class BasicMobileToolsLite:
                 pass
             
             if not close_candidates:
+                # 兜底策略：如果检测到弹窗但未找到关闭按钮，且页面元素很少（只有1个可点击元素），直接点击它
+                if popup_detected and popup_bounds and len(all_clickable_elements) == 1:
+                    single_element = all_clickable_elements[0]
+                    self.client.u2.click(single_element['center_x'], single_element['center_y'])
+                    time.sleep(0.5)
+                    
+                    # 检查应用是否跳转
+                    app_check = self._check_app_switched()
+                    return_result = None
+                    if app_check['switched']:
+                        return_result = self._return_to_target_app()
+                    
+                    # 记录操作
+                    rel_x = single_element['center_x'] / screen_width
+                    rel_y = single_element['center_y'] / screen_height
+                    self._record_click('percent', f"{round(rel_x * 100, 1)}%,{round(rel_y * 100, 1)}%", 
+                                      round(rel_x * 100, 1), round(rel_y * 100, 1),
+                                      element_desc="唯一可点击元素(弹窗兜底)")
+                    
+                    result = {"success": True, "clicked": True, "method": "single_clickable_fallback"}
+                    if app_check['switched']:
+                        result["switched"] = True
+                        if return_result:
+                            result["returned"] = return_result['success']
+                    return result
+                
+                # 如果没有找到关闭按钮，且不满足兜底条件，返回fallback
                 if popup_detected and popup_bounds:
                     return {"success": False, "fallback": "vision", "popup": True}
                 return {"success": True, "popup": False}
@@ -3062,6 +3472,15 @@ class BasicMobileToolsLite:
             resource_id = elem.attrib.get('resource-id', '')
             clickable = elem.attrib.get('clickable', 'false') == 'true'
             
+            # 检查是否是关闭按钮
+            is_close_button = (
+                'close' in resource_id.lower() or 
+                'dismiss' in resource_id.lower() or
+                'cancel' in resource_id.lower() or
+                '×' in elem.attrib.get('text', '') or
+                'X' in elem.attrib.get('text', '')
+            )
+            
             all_elements.append({
                 'idx': idx,
                 'bounds': (x1, y1, x2, y2),
@@ -3074,6 +3493,7 @@ class BasicMobileToolsLite:
                 'clickable': clickable,
                 'center_x': (x1 + x2) // 2,
                 'center_y': (y1 + y2) // 2,
+                'is_close_button': is_close_button,
             })
         
         if not all_elements:
@@ -3082,6 +3502,8 @@ class BasicMobileToolsLite:
         # 弹窗检测关键词
         dialog_class_keywords = ['Dialog', 'Popup', 'Alert', 'Modal', 'BottomSheet', 'PopupWindow']
         dialog_id_keywords = ['dialog', 'popup', 'alert', 'modal', 'bottom_sheet', 'overlay', 'mask']
+        # 广告弹窗关键词（全屏广告、激励视频等）
+        ad_popup_keywords = ['ad_close', 'ad_button', 'full_screen', 'interstitial', 'reward', 'close_icon', 'close_btn']
         
         popup_candidates = []
         has_mask_layer = False
@@ -3112,6 +3534,59 @@ class BasicMobileToolsLite:
             if y1 < 50:
                 continue
             
+            # 【非弹窗特征】如果元素包含底部导航栏（底部tab），则不是弹窗
+            # 底部导航栏通常在屏幕底部，高度约100-200像素
+            if y2 > screen_height * 0.85:
+                # 检查是否包含tab相关的resource-id或class
+                if 'tab' in resource_id.lower() or 'Tab' in class_name or 'navigation' in resource_id.lower():
+                    continue  # 跳过底部导航栏
+            
+            # 【非弹窗特征】如果元素包含顶部搜索栏，则不是弹窗
+            if y1 < screen_height * 0.15:
+                if 'search' in resource_id.lower() or 'Search' in class_name:
+                    continue  # 跳过顶部搜索栏
+            
+            # 先检查是否有强弹窗特征（用于后续判断）
+            has_strong_popup_feature = (
+                any(kw in class_name for kw in dialog_class_keywords) or
+                any(kw in resource_id.lower() for kw in dialog_id_keywords) or
+                any(kw in resource_id.lower() for kw in ad_popup_keywords)  # 广告弹窗关键词
+            )
+            
+            # 检查是否有子元素是关闭按钮（作为弹窗特征）
+            has_close_button_child = False
+            elem_bounds = elem['bounds']
+            for other_elem in all_elements:
+                if other_elem['idx'] == elem['idx']:
+                    continue
+                if other_elem['is_close_button']:
+                    # 检查关闭按钮是否在这个元素范围内
+                    ox1, oy1, ox2, oy2 = other_elem['bounds']
+                    ex1, ey1, ex2, ey2 = elem_bounds
+                    if ex1 <= ox1 and ey1 <= oy1 and ex2 >= ox2 and ey2 >= oy2:
+                        has_close_button_child = True
+                        break
+            
+            # 【非弹窗特征】如果元素包含明显的页面内容特征，则不是弹窗
+            # 检查是否包含视频播放器、内容列表等页面元素
+            page_content_keywords = ['video', 'player', 'recycler', 'list', 'scroll', 'viewpager', 'fragment']
+            if any(kw in resource_id.lower() or kw in class_name.lower() for kw in page_content_keywords):
+                # 如果面积很大且没有强弹窗特征，则不是弹窗
+                if area_ratio > 0.6 and not has_strong_popup_feature:
+                    continue
+            
+            # 【非弹窗特征】如果元素面积过大（接近全屏），即使居中也不应该是弹窗
+            # 真正的弹窗通常不会超过屏幕的60%
+            # 对于面积 > 0.6 的元素，如果没有强特征，直接跳过（避免误判首页内容区域）
+            if area_ratio > 0.6 and not has_strong_popup_feature:
+                continue  # 跳过大面积非弹窗元素（接近全屏的内容区域，如首页视频播放区域）
+            
+            # 对于面积 > 0.7 的元素，即使有强特征也要更严格
+            if area_ratio > 0.7:
+                # 需要非常强的特征才认为是弹窗
+                if not has_strong_popup_feature:
+                    continue
+            
             confidence = 0.0
             
             # 【强特征】class 名称包含弹窗关键词 (+0.5)
@@ -3122,19 +3597,46 @@ class BasicMobileToolsLite:
             if any(kw in resource_id.lower() for kw in dialog_id_keywords):
                 confidence += 0.4
             
+            # 【强特征】resource-id 包含广告弹窗关键词 (+0.4)
+            if any(kw in resource_id.lower() for kw in ad_popup_keywords):
+                confidence += 0.4
+            
+            # 【强特征】包含关闭按钮作为子元素 (+0.3)
+            if has_close_button_child:
+                confidence += 0.3
+            
             # 【中等特征】居中显示 (+0.2)
+            # 但如果没有强特征，降低权重
             center_x = elem['center_x']
             center_y = elem['center_y']
             is_centered_x = abs(center_x - screen_width / 2) < screen_width * 0.15
             is_centered_y = abs(center_y - screen_height / 2) < screen_height * 0.25
+            
+            has_strong_feature = (
+                any(kw in class_name for kw in dialog_class_keywords) or
+                any(kw in resource_id.lower() for kw in dialog_id_keywords) or
+                any(kw in resource_id.lower() for kw in ad_popup_keywords) or
+                has_close_button_child
+            )
+            
             if is_centered_x and is_centered_y:
-                confidence += 0.2
+                if has_strong_feature:
+                    confidence += 0.2
+                else:
+                    confidence += 0.1  # 没有强特征时降低权重
             elif is_centered_x:
-                confidence += 0.1
+                if has_strong_feature:
+                    confidence += 0.1
+                else:
+                    confidence += 0.05  # 没有强特征时降低权重
             
             # 【中等特征】非全屏但有一定大小 (+0.15)
+            # 但如果没有强特征，降低权重
             if 0.15 < area_ratio < 0.75:
-                confidence += 0.15
+                if has_strong_feature:
+                    confidence += 0.15
+                else:
+                    confidence += 0.08  # 没有强特征时降低权重
             
             # 【弱特征】XML 顺序靠后（在视图层级上层）(+0.1)
             if elem['idx'] > len(all_elements) * 0.5:
@@ -3161,8 +3663,22 @@ class BasicMobileToolsLite:
         popup_candidates.sort(key=lambda x: (x['confidence'], x['idx']), reverse=True)
         best = popup_candidates[0]
         
-        # 只有置信度 >= 0.6 才返回弹窗
-        if best['confidence'] >= 0.6:
+        # 更严格的阈值：只有置信度 >= 0.7 才返回弹窗
+        # 如果没有强特征（class或resource-id包含弹窗关键词），需要更高的置信度
+        has_strong_feature = (
+            any(kw in best['class'] for kw in dialog_class_keywords) or
+            any(kw in best['resource_id'].lower() for kw in dialog_id_keywords) or
+            any(kw in best['resource_id'].lower() for kw in ad_popup_keywords)
+        )
+        
+        if has_strong_feature:
+            # 有强特征时，阈值0.7
+            threshold = 0.7
+        else:
+            # 没有强特征时，阈值0.85（更严格）
+            threshold = 0.85
+        
+        if best['confidence'] >= threshold:
             return best['bounds'], best['confidence']
         
         return None, best['confidence']

mobile_mcp/mcp_tools/mcp_server.py

@@ -204,115 +204,6 @@ class MobileMCPServer:
         
         return "android"
     
-    def _open_new_chat(self, message: str = "继续执行飞书用例", delay: float = 5) -> dict:
-        """
-        打开新Chat窗口并发送消息
-        
-        原理：用后台线程延迟执行键盘操作，避免打断当前AI响应
-        跨平台统一用 pyautogui + pyperclip，配合系统API激活窗口
-        """
-        import threading
-        import platform
-        
-        def delayed_action():
-            import time
-            time.sleep(delay)  # 等待当前响应结束
-            
-            try:
-                system = platform.system()
-                
-                if system == "Darwin":  # ========== macOS: 纯 AppleScript（无需额外安装）==========
-                    import subprocess
-                    
-                    # AppleScript: 激活Cursor → Cmd+L聚焦Chat → Cmd+N新建 → 粘贴 → 回车
-                    script = f'''
-                    -- 设置剪贴板（支持中文）
-                    set the clipboard to "{message}"
-                    
-                    -- 激活 Cursor
-                    tell application "Cursor" to activate
-                    delay 0.5
-                    
-                    tell application "System Events"
-                        tell process "Cursor"
-                            -- Cmd+L 聚焦 Chat
-                            keystroke "l" using command down
-                            delay 0.5
-                            -- Cmd+N 新建对话
-                            keystroke "n" using command down
-                            delay 1
-                            -- Cmd+V 粘贴
-                            keystroke "v" using command down
-                            delay 0.3
-                            -- Enter 发送
-                            key code 36
-                        end tell
-                    end tell
-                    '''
-                    result = subprocess.run(['osascript', '-e', script], capture_output=True, text=True)
-                    if result.returncode == 0:
-                        print(f"[open_new_chat] macOS成功: {message}", file=sys.stderr)
-                    else:
-                        print(f"[open_new_chat] AppleScript错误: {result.stderr}", file=sys.stderr)
-                    
-                elif system == "Windows":  # ========== Windows: 需要 pip install pyautogui pyperclip ==========
-                    import pyautogui
-                    import pyperclip
-                    
-                    # 尝试激活 Cursor 窗口
-                    try:
-                        import pygetwindow as gw
-                        windows = gw.getWindowsWithTitle('Cursor')
-                        if windows:
-                            windows[0].activate()
-                            time.sleep(0.5)
-                    except ImportError:
-                        pass
-                    
-                    pyautogui.PAUSE = 0.3
-                    
-                    # Ctrl+L 聚焦 Chat → Ctrl+N 新建
-                    pyautogui.hotkey('ctrl', 'l')
-                    time.sleep(0.5)
-                    pyautogui.hotkey('ctrl', 'n')
-                    time.sleep(1)
-                    
-                    # 粘贴消息
-                    pyperclip.copy(message)
-                    pyautogui.hotkey('ctrl', 'v')
-                    time.sleep(0.3)
-                    pyautogui.press('enter')
-                    
-                    print(f"[open_new_chat] Windows成功: {message}", file=sys.stderr)
-                    
-                else:  # Linux: 写信号文件
-                    from pathlib import Path
-                    signal_file = Path(__file__).parent.parent / ".new_chat_signal"
-                    signal_file.write_text(message)
-                    print(f"[open_new_chat] Linux: 已写入信号文件", file=sys.stderr)
-                    
-            except ImportError as e:
-                # Windows 缺少依赖时写信号文件
-                from pathlib import Path
-                signal_file = Path(__file__).parent.parent / ".new_chat_signal"
-                signal_file.write_text(message)
-                print(f"[open_new_chat] Windows缺少依赖，请运行: pip install pyautogui pyperclip", file=sys.stderr)
-                    
-            except Exception as e:
-                # 写错误日志
-                import sys
-                print(f"[open_new_chat] 错误: {e}", file=sys.stderr)
-        
-        # 后台线程执行，不阻塞MCP响应
-        thread = threading.Thread(target=delayed_action, daemon=True)
-        thread.start()
-        
-        return {
-            "success": True,
-            "message": f"⏰ {delay}秒后将打开新Chat并发送: {message}",
-            "tip": "请不要手动操作，等待自动执行"
-        }
-    
     def get_tools(self):
         """注册 MCP 工具"""
         tools = []
@@ -603,18 +494,82 @@ class MobileMCPServer:
         # ==================== 导航操作 ====================
         tools.append(Tool(
             name="mobile_swipe",
-            description="👆 滑动。方向:up/down/left/right。",
+            description="👆 滑动屏幕。方向：up/down/left/right\n\n"
+                       "🎯 适用场景：\n"
+                       "- 滑动页面（列表、页面切换）\n"
+                       "- 拖动进度条/滑块（SeekBar、ProgressBar）\n"
+                       "- 滑动选择器（Picker、Slider）\n\n"
+                       "💡 左右滑动时，可指定高度坐标或百分比：\n"
+                       "- y: 指定高度坐标（像素）\n"
+                       "- y_percent: 指定高度百分比 (0-100)\n"
+                       "- 两者都未指定时，使用屏幕中心高度\n"
+                       "- 📌 拖动进度条时，使用进度条的 Y 位置（百分比或像素）\n\n"
+                       "💡 横向滑动（left/right）时，可指定滑动距离：\n"
+                       "- distance: 滑动距离（像素）\n"
+                       "- distance_percent: 滑动距离百分比 (0-100)\n"
+                       "- 两者都未指定时，使用默认距离（屏幕宽度的 60%）\n"
+                       "- 📌 拖动进度条时，distance_percent 控制拖动幅度\n\n"
+                       "💡 拖动进度条示例：\n"
+                       "- 倒退：direction='left', y_percent=91（进度条位置）, distance_percent=30\n"
+                       "- 前进：direction='right', y_percent=91, distance_percent=30\n\n"
+                       "⚠️ **推荐使用 mobile_drag_progress_bar 拖动进度条**（自动检测进度条位置，无需手动指定）",
             inputSchema={
                 "type": "object",
                 "properties": {
                     "direction": {"type": "string", "enum": ["up", "down", "left", "right"], "description": "方向"},
-                    "y": {"type": "integer", "description": "左右滑动高度(px)"},
-                    "y_percent": {"type": "number", "description": "左右滑动高度(%)"}
+                    "y": {"type": "integer", "description": "左右滑动时指定的高度坐标（像素）"},
+                    "y_percent": {"type": "number", "description": "左右滑动时指定的高度百分比 (0-100)"},
+                    "distance": {"type": "integer", "description": "横向滑动时指定的滑动距离（像素），仅用于 left/right"},
+                    "distance_percent": {"type": "number", "description": "横向滑动时指定的滑动距离百分比 (0-100)，仅用于 left/right"}
                 },
                 "required": ["direction"]
             }
         ))
         
+        tools.append(Tool(
+            name="mobile_drag_progress_bar",
+            description="🎯 智能拖动进度条（⭐⭐ 推荐用于拖动视频/音频进度条）\n\n"
+                       "✅ **自动检测进度条是否可见**：\n"
+                       "- 如果进度条已显示，直接拖动（无需先点击播放区域）\n"
+                       "- 如果进度条未显示，自动点击播放区域显示控制栏，再拖动\n\n"
+                       "🎯 优势：\n"
+                       "- 自动检测进度条位置，无需手动指定 y_percent\n"
+                       "- 智能判断是否需要显示控制栏\n"
+                       "- 使用 swipe 拖动，更稳定可靠\n\n"
+                       "💡 参数说明：\n"
+                       "- direction: 'left'（倒退）或 'right'（前进），默认 'right'\n"
+                       "- distance_percent: 拖动距离百分比 (0-100)，默认 30%\n"
+                       "- y_percent: 进度条位置（可选，未指定则自动检测）\n"
+                       "- y: 进度条位置坐标（可选，未指定则自动检测）\n\n"
+                       "📋 使用示例：\n"
+                       "- 前进30%：mobile_drag_progress_bar(direction='right', distance_percent=30)\n"
+                       "- 倒退30%：mobile_drag_progress_bar(direction='left', distance_percent=30)\n"
+                       "- 前进到指定位置：先点击进度条位置，或使用 mobile_swipe",
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "direction": {
+                        "type": "string",
+                        "enum": ["left", "right"],
+                        "description": "拖动方向：'left'（倒退）或 'right'（前进），默认 'right'"
+                    },
+                    "distance_percent": {
+                        "type": "number",
+                        "description": "拖动距离百分比 (0-100)，默认 30%"
+                    },
+                    "y_percent": {
+                        "type": "number",
+                        "description": "进度条的垂直位置百分比 (0-100)，可选，未指定则自动检测"
+                    },
+                    "y": {
+                        "type": "integer",
+                        "description": "进度条的垂直位置坐标（像素），可选，未指定则自动检测"
+                    }
+                },
+                "required": []
+            }
+        ))
+        
         tools.append(Tool(
             name="mobile_press_key",
             description="⌨️ 按键:home/back/enter/search。",
@@ -730,6 +685,8 @@ class MobileMCPServer:
 - 如果没有弹窗 → 直接返回"无弹窗"，不执行任何操作
 - 如果有弹窗 → 自动查找并点击关闭按钮
 
+💡 【优化】如果已通过list_elements识别到弹窗，可传入popup_detected=true跳过重复检测
+
 ✅ 适用场景：
 - 启动应用后检测并关闭可能出现的弹窗
 - 页面跳转后检测并关闭弹窗
@@ -745,7 +702,21 @@ class MobileMCPServer:
         tools.append(Tool(
             name="mobile_close_popup",
             description=desc_close_popup,
-            inputSchema={"type": "object", "properties": {}, "required": []}
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "popup_detected": {
+                        "type": "boolean",
+                        "description": "可选，如果已通过list_elements识别到弹窗，传入true可跳过重复检测"
+                    },
+                    "popup_bounds": {
+                        "type": "array",
+                        "items": {"type": "number"},
+                        "description": "可选，弹窗边界[x1, y1, x2, y2]，如果已识别到弹窗区域可传入"
+                    }
+                },
+                "required": []
+            }
         ))
         
         tools.append(Tool(
@@ -896,20 +867,6 @@ class MobileMCPServer:
             }
         ))
         
-        # ==================== Cursor自动化 ====================
-        tools.append(Tool(
-            name="mobile_open_new_chat",
-            description="🔄 打开新Chat继续执行。执行完10个用例后调用，会延迟5秒后按Cmd+T打开新会话并输入继续命令。",
-            inputSchema={
-                "type": "object",
-                "properties": {
-                    "message": {"type": "string", "description": "新会话中要发送的消息", "default": "继续执行飞书用例"},
-                    "delay": {"type": "number", "description": "延迟秒数（等待当前响应结束）", "default": 5}
-                },
-                "required": []
-            }
-        ))
-        
         return tools
     
     async def handle_tool_call(self, name: str, arguments: dict):
@@ -1047,7 +1004,18 @@ class MobileMCPServer:
                 result = await self.tools.swipe(
                     arguments["direction"],
                     y=arguments.get("y"),
-                    y_percent=arguments.get("y_percent")
+                    y_percent=arguments.get("y_percent"),
+                    distance=arguments.get("distance"),
+                    distance_percent=arguments.get("distance_percent")
+                )
+                return [TextContent(type="text", text=self.format_response(result))]
+            
+            elif name == "mobile_drag_progress_bar":
+                result = await self.tools.drag_progress_bar(
+                    direction=arguments.get("direction", "right"),
+                    distance_percent=arguments.get("distance_percent", 30.0),
+                    y_percent=arguments.get("y_percent"),
+                    y=arguments.get("y")
                 )
                 return [TextContent(type="text", text=self.format_response(result))]
             
@@ -1091,7 +1059,17 @@ class MobileMCPServer:
                 return [TextContent(type="text", text=self.format_response(result))]
             
             elif name == "mobile_close_popup":
-                result = self.tools.close_popup()
+                popup_detected = arguments.get("popup_detected")
+                popup_bounds = arguments.get("popup_bounds")
+                # 如果传入了popup_bounds，转换为tuple
+                if popup_bounds and isinstance(popup_bounds, list) and len(popup_bounds) == 4:
+                    popup_bounds = tuple(popup_bounds)
+                elif popup_bounds:
+                    popup_bounds = None  # 格式不正确，忽略
+                result = self.tools.close_popup(
+                    popup_detected=popup_detected,
+                    popup_bounds=popup_bounds
+                )
                 return [TextContent(type="text", text=self.format_response(result))]
             
             elif name == "mobile_assert_text":
@@ -1174,13 +1152,6 @@ class MobileMCPServer:
                     result = {"success": False, "error": "请提供 x_percent/y_percent 或 screenshot_path/x/y/width/height"}
                 return [TextContent(type="text", text=self.format_response(result))]
             
-            # Cursor自动化：打开新Chat
-            elif name == "mobile_open_new_chat":
-                message = arguments.get("message", "继续执行飞书用例")
-                delay = arguments.get("delay", 5)
-                result = self._open_new_chat(message, delay)
-                return [TextContent(type="text", text=self.format_response(result))]
-            
             else:
                 return [TextContent(type="text", text=f"❌ 未知工具: {name}")]
         

{mobile_mcp_ai-2.7.0.dist-info → mobile_mcp_ai-2.7.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mobile-mcp-ai
-Version: 2.7.0
+Version: 2.7.4
 Summary: 移动端自动化 MCP Server - 支持 Android/iOS，AI 功能可选（基础工具不需要 AI）
 Home-page: https://github.com/test111ddff-hash/mobile-mcp-ai
 Author: douzi

{mobile_mcp_ai-2.7.0.dist-info → mobile_mcp_ai-2.7.4.dist-info}/RECORD

@@ -1,7 +1,7 @@
 mobile_mcp/__init__.py,sha256=sQJZTL_sxQFzmcS7jOtS2AHCfUySz40vhX96N6u1qy4,816
 mobile_mcp/config.py,sha256=-xSl9vahp3EFAA97P1ahcnQC-HHAFvccGHpnFAXeKHU,5841
 mobile_mcp/core/__init__.py,sha256=ndMy-cLAIsQDG5op7gM_AIplycqZSZPWEkec1pEhvEY,170
-mobile_mcp/core/basic_tools_lite.py,sha256=8l0zxzFBB-41c_uVcS-5Z4slzawNGa7yu1GglYAkhME,193754
+mobile_mcp/core/basic_tools_lite.py,sha256=tclg7m7STWaWwSizAhK-MeZhsvboKqjKo_t5ZKEt0n4,221624
 mobile_mcp/core/device_manager.py,sha256=xG5DoeNFs45pl-FTEhEWblqVwxtFK-FmVEGlNL6EqRI,8798
 mobile_mcp/core/dynamic_config.py,sha256=Ja1n1pfb0HspGByqk2_A472mYVniKmGtNEWyjUjmgK8,9811
 mobile_mcp/core/ios_client_wda.py,sha256=Nq9WxevhTWpVpolM-Ymp-b0nUQV3tXLFszmJHbDC4wA,18770
@@ -19,14 +19,14 @@ mobile_mcp/core/utils/logger.py,sha256=XXQAHUwT1jc70pq_tYFmL6f_nKrFlYm3hcgl-5RYR
 mobile_mcp/core/utils/operation_history_manager.py,sha256=gi8S8HJAMqvkUrY7_-kVbko3Xt7c4GAUziEujRd-N-Y,4792
 mobile_mcp/core/utils/smart_wait.py,sha256=N5wKTUYrNWPruBILqrAjpvtso8Z3GRWCfMIR_aZxPLg,8649
 mobile_mcp/mcp_tools/__init__.py,sha256=xkro8Rwqv_55YlVyhh-3DgRFSsLE3h1r31VIb3bpM6E,143
-mobile_mcp/mcp_tools/mcp_server.py,sha256=nY_4jrdn4siJtm2HvettTv5bTN0rq9iJvwqBMlI7sMc,53175
+mobile_mcp/mcp_tools/mcp_server.py,sha256=nEb_chFF_1lN__4nMei2yPzVgzlDeYK67p-KJVta-VU,53521
 mobile_mcp/utils/__init__.py,sha256=8EH0i7UGtx1y_j_GEgdN-cZdWn2sRtZSEOLlNF9HRnY,158
 mobile_mcp/utils/logger.py,sha256=Sqq2Nr0Y4p03erqcrbYKVPCGiFaNGHMcE_JwCkeOfU4,3626
 mobile_mcp/utils/xml_formatter.py,sha256=uwTRb3vLbqhT8O-udzWT7s7LsV-DyDUz2DkofD3hXOE,4556
 mobile_mcp/utils/xml_parser.py,sha256=QhL8CWbdmNDzmBLjtx6mEnjHgMFZzJeHpCL15qfXSpI,3926
-mobile_mcp_ai-2.7.0.dist-info/licenses/LICENSE,sha256=HrhfyXIkWY2tGFK11kg7vPCqhgh5DcxleloqdhrpyMY,11558
-mobile_mcp_ai-2.7.0.dist-info/METADATA,sha256=-yl4iprOIClkYPv7YmyRLrDF9QBlRvhkro86tuqYr6U,11505
-mobile_mcp_ai-2.7.0.dist-info/WHEEL,sha256=qELbo2s1Yzl39ZmrAibXA2jjPLUYfnVhUNTlyF1rq0Y,92
-mobile_mcp_ai-2.7.0.dist-info/entry_points.txt,sha256=KB_FglozgPHBprSM1vFbIzGyheFuHFmGanscRdMJ_8A,68
-mobile_mcp_ai-2.7.0.dist-info/top_level.txt,sha256=lLm6YpbTv855Lbh8BIA0rPxhybIrvYUzMEk9OErHT94,11
-mobile_mcp_ai-2.7.0.dist-info/RECORD,,
+mobile_mcp_ai-2.7.4.dist-info/licenses/LICENSE,sha256=HrhfyXIkWY2tGFK11kg7vPCqhgh5DcxleloqdhrpyMY,11558
+mobile_mcp_ai-2.7.4.dist-info/METADATA,sha256=L46BIHR90WVEk5KCH4WvCmP6kM2H3XnLETW3w2wFg8Y,11505
+mobile_mcp_ai-2.7.4.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+mobile_mcp_ai-2.7.4.dist-info/entry_points.txt,sha256=KB_FglozgPHBprSM1vFbIzGyheFuHFmGanscRdMJ_8A,68
+mobile_mcp_ai-2.7.4.dist-info/top_level.txt,sha256=lLm6YpbTv855Lbh8BIA0rPxhybIrvYUzMEk9OErHT94,11
+mobile_mcp_ai-2.7.4.dist-info/RECORD,,

{mobile_mcp_ai-2.7.0.dist-info → mobile_mcp_ai-2.7.4.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.10.1)
+Generator: setuptools (80.10.2)
 Root-Is-Purelib: true
 Tag: py3-none-any