mobile-mcp-ai 2.3.4__tar.gz → 2.4.1__tar.gz

{mobile_mcp_ai-2.3.4/mobile_mcp_ai.egg-info → mobile_mcp_ai-2.4.1}/PKG-INFO

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

{mobile_mcp_ai-2.3.4 → mobile_mcp_ai-2.4.1}/core/basic_tools_lite.py

@@ -56,8 +56,9 @@ class BasicMobileToolsLite:
     # ==================== 截图 ====================
     
     def take_screenshot(self, description: str = "", compress: bool = True, 
-                        max_width: int = 720, quality: int = 75) -> Dict:
-        """截图（支持压缩，省 token）
+                        max_width: int = 720, quality: int = 75,
+                        crop_x: int = 0, crop_y: int = 0, crop_size: int = 0) -> Dict:
+        """截图（支持压缩和局部裁剪）
         
         压缩原理：
         1. 先截取原始 PNG 图片
@@ -65,11 +66,20 @@ class BasicMobileToolsLite:
         3. 转换为 JPEG 格式 + 降低质量（如 100% → 75%）
         4. 最终文件从 2MB 压缩到约 80KB（节省 96%）
         
+        局部裁剪（用于精确识别小元素）：
+        - 第一次全屏截图，AI 返回大概坐标
+        - 第二次传入 crop_x, crop_y, crop_size 截取局部区域
+        - 局部区域不压缩，保持清晰度，AI 可精确识别
+        - 返回 crop_offset_x/y 用于坐标换算
+        
         Args:
             description: 截图描述（可选）
             compress: 是否压缩（默认 True，推荐开启省 token）
             max_width: 压缩后最大宽度（默认 720，对 AI 识别足够）
             quality: JPEG 质量 1-100（默认 75，肉眼几乎看不出区别）
+            crop_x: 裁剪中心点 X 坐标（屏幕坐标，0 表示不裁剪）
+            crop_y: 裁剪中心点 Y 坐标（屏幕坐标，0 表示不裁剪）
+            crop_size: 裁剪区域大小（默认 0 不裁剪，推荐 200-400）
         
         压缩效果示例：
             原图 PNG: 2048KB
@@ -104,12 +114,74 @@ class BasicMobileToolsLite:
             
             original_size = temp_path.stat().st_size
             
-            if compress:
-                # 第2步：打开图片
-                img = Image.open(temp_path)
+            # 第2步：打开图片
+            img = Image.open(temp_path)
+            
+            # 第2.5步：局部裁剪（如果指定了裁剪参数）
+            crop_offset_x, crop_offset_y = 0, 0
+            is_cropped = False
+            
+            if crop_x > 0 and crop_y > 0 and crop_size > 0:
+                # 计算裁剪区域（以 crop_x, crop_y 为中心）
+                half_size = crop_size // 2
+                left = max(0, crop_x - half_size)
+                top = max(0, crop_y - half_size)
+                right = min(img.width, crop_x + half_size)
+                bottom = min(img.height, crop_y + half_size)
+                
+                # 记录偏移量（用于坐标换算）
+                crop_offset_x = left
+                crop_offset_y = top
+                
+                # 裁剪
+                img = img.crop((left, top, right, bottom))
+                is_cropped = True
+            
+            # ========== 情况1：局部裁剪截图（不压缩，保持清晰度）==========
+            if is_cropped:
+                # 生成文件名
+                if description:
+                    safe_desc = re.sub(r'[^\w\s-]', '', description).strip().replace(' ', '_')
+                    filename = f"screenshot_{platform}_crop_{safe_desc}_{timestamp}.png"
+                else:
+                    filename = f"screenshot_{platform}_crop_{timestamp}.png"
+                
+                final_path = self.screenshot_dir / filename
+                
+                # 保存为 PNG（保持清晰度）
+                img.save(str(final_path), "PNG")
+                
+                # 删除临时文件
+                temp_path.unlink()
+                
+                cropped_size = final_path.stat().st_size
+                
+                return {
+                    "success": True,
+                    "screenshot_path": str(final_path),
+                    "screen_width": screen_width,
+                    "screen_height": screen_height,
+                    "image_width": img.width,
+                    "image_height": img.height,
+                    "crop_offset_x": crop_offset_x,
+                    "crop_offset_y": crop_offset_y,
+                    "file_size": f"{cropped_size/1024:.1f}KB",
+                    "message": f"🔍 局部截图已保存: {final_path}\n"
+                              f"📐 裁剪区域: ({crop_offset_x}, {crop_offset_y}) 起，{img.width}x{img.height} 像素\n"
+                              f"📦 文件大小: {cropped_size/1024:.0f}KB\n"
+                              f"🎯 【坐标换算】AI 返回坐标 (x, y) 后：\n"
+                              f"   实际屏幕坐标 = ({crop_offset_x} + x, {crop_offset_y} + y)\n"
+                              f"   或直接调用 mobile_click_at_coords(x, y, crop_offset_x={crop_offset_x}, crop_offset_y={crop_offset_y})"
+                }
+            
+            # ========== 情况2：全屏压缩截图 ==========
+            elif compress:
+                # 🔴 关键：记录原始图片尺寸（用于坐标转换）
+                # 注意：截图尺寸可能和 u2.info 的 displayWidth 不一致！
+                original_img_width = img.width
+                original_img_height = img.height
                 
                 # 第3步：缩小尺寸（保持宽高比）
-                # 记录压缩后的图片尺寸（用于坐标转换）
                 image_width, image_height = img.width, img.height
                 
                 if img.width > max_width:
@@ -118,20 +190,16 @@ class BasicMobileToolsLite:
                     new_h = int(img.height * ratio)
                     # 兼容不同版本的 Pillow
                     try:
-                        # Pillow 10.0.0+
                         resample = Image.Resampling.LANCZOS
                     except AttributeError:
                         try:
-                            # Pillow 9.x
                             resample = Image.LANCZOS
                         except AttributeError:
-                            # Pillow 旧版本
                             resample = Image.ANTIALIAS
                     img = img.resize((new_w, new_h), resample)
-                    # 更新为压缩后的尺寸
                     image_width, image_height = new_w, new_h
                 
-                # 第4步：生成最终文件名（JPEG 格式）
+                # 生成文件名（JPEG 格式）
                 if description:
                     safe_desc = re.sub(r'[^\w\s-]', '', description).strip().replace(' ', '_')
                     filename = f"screenshot_{platform}_{safe_desc}_{timestamp}.jpg"
@@ -140,10 +208,8 @@ class BasicMobileToolsLite:
                 
                 final_path = self.screenshot_dir / filename
                 
-                # 第5步：保存为 JPEG（PNG 可能有透明通道，需转 RGB）
-                # 先转换为 RGB 模式，处理可能的 RGBA 或 P 模式
+                # 保存为 JPEG（处理透明通道）
                 if img.mode in ('RGBA', 'LA', 'P'):
-                    # 创建白色背景
                     background = Image.new('RGB', img.size, (255, 255, 255))
                     if img.mode == 'P':
                         img = img.convert('RGBA')
@@ -153,8 +219,6 @@ class BasicMobileToolsLite:
                     img = img.convert("RGB")
                 
                 img.save(str(final_path), "JPEG", quality=quality)
-                
-                # 第6步：删除临时 PNG
                 temp_path.unlink()
                 
                 compressed_size = final_path.stat().st_size
@@ -165,21 +229,23 @@ class BasicMobileToolsLite:
                     "screenshot_path": str(final_path),
                     "screen_width": screen_width,
                     "screen_height": screen_height,
-                    "image_width": image_width,
-                    "image_height": image_height,
+                    "original_img_width": original_img_width,    # 截图原始宽度
+                    "original_img_height": original_img_height,  # 截图原始高度
+                    "image_width": image_width,                  # 压缩后宽度（AI 看到的）
+                    "image_height": image_height,                # 压缩后高度（AI 看到的）
                     "original_size": f"{original_size/1024:.1f}KB",
                     "compressed_size": f"{compressed_size/1024:.1f}KB",
                     "saved_percent": f"{saved_percent:.0f}%",
                     "message": f"📸 截图已保存: {final_path}\n"
-                              f"📐 屏幕尺寸: {screen_width}x{screen_height}\n"
-                              f"🖼️ 图片尺寸: {image_width}x{image_height}（AI 分析用）\n"
+                              f"📐 原始尺寸: {original_img_width}x{original_img_height} → 压缩后: {image_width}x{image_height}\n"
                               f"📦 已压缩: {original_size/1024:.0f}KB → {compressed_size/1024:.0f}KB (省 {saved_percent:.0f}%)\n"
-                              f"⚠️ 【重要】AI 返回的坐标需要转换！\n"
-                              f"   请使用 mobile_click_at_coords 并传入 image_width={image_width}, image_height={image_height}\n"
-                              f"   工具会自动将图片坐标转换为屏幕坐标"
+                              f"⚠️ 【坐标转换】AI 返回坐标后，请传入：\n"
+                              f"   image_width={image_width}, image_height={image_height},\n"
+                              f"   original_img_width={original_img_width}, original_img_height={original_img_height}"
                 }
+            
+            # ========== 情况3：全屏不压缩截图 ==========
             else:
-                # 不压缩，直接重命名临时文件
                 if description:
                     safe_desc = re.sub(r'[^\w\s-]', '', description).strip().replace(' ', '_')
                     filename = f"screenshot_{platform}_{safe_desc}_{timestamp}.png"
@@ -189,19 +255,21 @@ class BasicMobileToolsLite:
                 final_path = self.screenshot_dir / filename
                 temp_path.rename(final_path)
                 
-                # 不压缩时，图片尺寸 = 屏幕尺寸
+                # 不压缩时，用截图实际尺寸（可能和 screen_width 不同）
                 return {
                     "success": True,
                     "screenshot_path": str(final_path),
                     "screen_width": screen_width,
                     "screen_height": screen_height,
-                    "image_width": screen_width,
-                    "image_height": screen_height,
+                    "original_img_width": img.width,   # 截图实际尺寸
+                    "original_img_height": img.height,
+                    "image_width": img.width,          # 未压缩，和原图一样
+                    "image_height": img.height,
                     "file_size": f"{original_size/1024:.1f}KB",
                     "message": f"📸 截图已保存: {final_path}\n"
-                              f"📐 屏幕尺寸: {screen_width}x{screen_height}\n"
+                              f"📐 截图尺寸: {img.width}x{img.height}\n"
                               f"📦 文件大小: {original_size/1024:.0f}KB（未压缩）\n"
-                              f"💡 Cursor 分析图片后，返回的坐标可直接用于 mobile_click_at_coords"
+                              f"💡 未压缩，坐标可直接使用"
                 }
         except ImportError:
             # 如果没有 PIL，回退到原始方式（不压缩）
@@ -281,18 +349,24 @@ class BasicMobileToolsLite:
     
     # ==================== 点击操作 ====================
     
-    def click_at_coords(self, x: int, y: int, image_width: int = 0, image_height: int = 0) -> Dict:
+    def click_at_coords(self, x: int, y: int, image_width: int = 0, image_height: int = 0,
+                        crop_offset_x: int = 0, crop_offset_y: int = 0,
+                        original_img_width: int = 0, original_img_height: int = 0) -> Dict:
         """点击坐标（核心功能，支持自动坐标转换）
         
         Args:
             x: X 坐标（来自截图分析或屏幕坐标）
             y: Y 坐标（来自截图分析或屏幕坐标）
-            image_width: 截图的宽度（可选，传入后自动转换坐标）
-            image_height: 截图的高度（可选，传入后自动转换坐标）
+            image_width: 压缩后图片宽度（AI 看到的图片尺寸）
+            image_height: 压缩后图片高度（AI 看到的图片尺寸）
+            crop_offset_x: 局部截图的 X 偏移量（局部截图时传入）
+            crop_offset_y: 局部截图的 Y 偏移量（局部截图时传入）
+            original_img_width: 截图原始宽度（压缩前的尺寸，用于精确转换）
+            original_img_height: 截图原始高度（压缩前的尺寸，用于精确转换）
         
         坐标转换说明：
-            如果截图被压缩过（如 1080→720），AI 返回的坐标是基于压缩图的。
-            传入 image_width/image_height 后，工具会自动将坐标转换为屏幕坐标。
+            1. 全屏压缩截图：AI 坐标 → 原图坐标（基于 image/original_img 比例）
+            2. 局部裁剪截图：AI 坐标 + 偏移量 = 屏幕坐标
         """
         try:
             # 获取屏幕尺寸
@@ -309,15 +383,30 @@ class BasicMobileToolsLite:
                 screen_width = info.get('displayWidth', 0)
                 screen_height = info.get('displayHeight', 0)
             
-            # 🎯 坐标转换：如果传入了图片尺寸，将图片坐标转换为屏幕坐标
+            # 🎯 坐标转换
             original_x, original_y = x, y
             converted = False
-            if image_width > 0 and image_height > 0 and screen_width > 0 and screen_height > 0:
-                if image_width != screen_width or image_height != screen_height:
-                    # 按比例转换坐标
-                    x = int(x * screen_width / image_width)
-                    y = int(y * screen_height / image_height)
-                    converted = True
+            conversion_type = ""
+            
+            # 情况1：局部裁剪截图 - 加上偏移量
+            if crop_offset_x > 0 or crop_offset_y > 0:
+                x = x + crop_offset_x
+                y = y + crop_offset_y
+                converted = True
+                conversion_type = "crop_offset"
+            # 情况2：全屏压缩截图 - 按比例转换到原图尺寸
+            elif image_width > 0 and image_height > 0:
+                # 优先使用 original_img_width/height（更精确）
+                # 如果没传，则用 screen_width/height（兼容旧版本）
+                target_width = original_img_width if original_img_width > 0 else screen_width
+                target_height = original_img_height if original_img_height > 0 else screen_height
+                
+                if target_width > 0 and target_height > 0:
+                    if image_width != target_width or image_height != target_height:
+                        x = int(x * target_width / image_width)
+                        y = int(y * target_height / image_height)
+                        converted = True
+                        conversion_type = "scale"
             
             # 执行点击
             if self._is_ios():
@@ -345,12 +434,19 @@ class BasicMobileToolsLite:
             )
             
             if converted:
-                return {
-                    "success": True,
-                    "message": f"✅ 点击成功: ({x}, {y})\n"
-                              f"   📐 坐标已转换: ({original_x},{original_y}) → ({x},{y})\n"
-                              f"   🖼️ 图片尺寸: {image_width}x{image_height} → 屏幕: {screen_width}x{screen_height}"
-                }
+                if conversion_type == "crop_offset":
+                    return {
+                        "success": True,
+                        "message": f"✅ 点击成功: ({x}, {y})\n"
+                                  f"   🔍 局部截图坐标转换: ({original_x},{original_y}) + 偏移({crop_offset_x},{crop_offset_y}) → ({x},{y})"
+                    }
+                else:
+                    return {
+                        "success": True,
+                        "message": f"✅ 点击成功: ({x}, {y})\n"
+                                  f"   📐 坐标已转换: ({original_x},{original_y}) → ({x},{y})\n"
+                                  f"   🖼️ 图片尺寸: {image_width}x{image_height} → 屏幕: {screen_width}x{screen_height}"
+                    }
             else:
                 return {
                     "success": True,
@@ -556,7 +652,14 @@ class BasicMobileToolsLite:
     # ==================== 输入操作 ====================
     
     def input_text_by_id(self, resource_id: str, text: str) -> Dict:
-        """通过 resource-id 输入文本"""
+        """通过 resource-id 输入文本
+        
+        优化策略：
+        1. 先用 resourceId 定位
+        2. 如果只有 1 个元素 → 直接输入
+        3. 如果有多个相同 ID（>5个说明 ID 不可靠）→ 改用 EditText 类型定位
+        4. 多个 EditText 时选择最靠上的（搜索框通常在顶部）
+        """
         try:
             if self._is_ios():
                 ios_client = self._get_ios_client()
@@ -571,13 +674,70 @@ class BasicMobileToolsLite:
                         return {"success": True, "message": f"✅ 输入成功: '{text}'"}
                     return {"success": False, "message": f"❌ 输入框不存在: {resource_id}"}
             else:
-                elem = self.client.u2(resourceId=resource_id)
-                if elem.exists(timeout=0.5):
-                    elem.set_text(text)
-                    time.sleep(0.3)
-                    self._record_operation('input', element=resource_id, ref=resource_id, text=text)
-                    return {"success": True, "message": f"✅ 输入成功: '{text}'"}
+                elements = self.client.u2(resourceId=resource_id)
+                
+                # 检查是否存在
+                if elements.exists(timeout=0.5):
+                    count = elements.count
+                    
+                    # 只有 1 个元素，直接输入
+                    if count == 1:
+                        elements.set_text(text)
+                        time.sleep(0.3)
+                        self._record_operation('input', element=resource_id, ref=resource_id, text=text)
+                        return {"success": True, "message": f"✅ 输入成功: '{text}'"}
+                    
+                    # 多个相同 ID（<=5个），尝试智能选择
+                    if count <= 5:
+                        for i in range(count):
+                            try:
+                                elem = elements[i]
+                                info = elem.info
+                                # 优先选择可编辑的
+                                if info.get('editable') or info.get('focusable'):
+                                    elem.set_text(text)
+                                    time.sleep(0.3)
+                                    self._record_operation('input', element=resource_id, ref=resource_id, text=text)
+                                    return {"success": True, "message": f"✅ 输入成功: '{text}'"}
+                            except:
+                                continue
+                        # 没找到可编辑的，用第一个
+                        elements[0].set_text(text)
+                        time.sleep(0.3)
+                        self._record_operation('input', element=resource_id, ref=resource_id, text=text)
+                        return {"success": True, "message": f"✅ 输入成功: '{text}'"}
+                
+                # ID 不可靠（不存在或太多），改用 EditText 类型定位
+                edit_texts = self.client.u2(className='android.widget.EditText')
+                if edit_texts.exists(timeout=0.5):
+                    et_count = edit_texts.count
+                    if et_count == 1:
+                        edit_texts.set_text(text)
+                        time.sleep(0.3)
+                        self._record_operation('input', element='EditText', ref='EditText', text=text)
+                        return {"success": True, "message": f"✅ 输入成功: '{text}' (通过 EditText 定位)"}
+                    
+                    # 多个 EditText，选择最靠上的
+                    best_elem = None
+                    min_top = 9999
+                    for i in range(et_count):
+                        try:
+                            elem = edit_texts[i]
+                            top = elem.info.get('bounds', {}).get('top', 9999)
+                            if top < min_top:
+                                min_top = top
+                                best_elem = elem
+                        except:
+                            continue
+                    
+                    if best_elem:
+                        best_elem.set_text(text)
+                        time.sleep(0.3)
+                        self._record_operation('input', element='EditText', ref='EditText', text=text)
+                        return {"success": True, "message": f"✅ 输入成功: '{text}' (通过 EditText 定位，选择最顶部的)"}
+                
                 return {"success": False, "message": f"❌ 输入框不存在: {resource_id}"}
+                    
         except Exception as e:
             return {"success": False, "message": f"❌ 输入失败: {e}"}
     
@@ -841,6 +1001,510 @@ class BasicMobileToolsLite:
         except Exception as e:
             return [{"error": f"获取元素失败: {e}"}]
     
+    def find_close_button(self) -> Dict:
+        """智能查找关闭按钮（不点击，只返回位置）
+        
+        从元素列表中找最可能的关闭按钮，返回其坐标和百分比位置。
+        适用于关闭弹窗广告等场景。
+        
+        Returns:
+            包含关闭按钮位置信息的字典，或截图让 AI 分析
+        """
+        try:
+            import re
+            
+            if self._is_ios():
+                return {"success": False, "message": "iOS 暂不支持，请使用截图+坐标点击"}
+            
+            # 获取屏幕尺寸
+            screen_width = self.client.u2.info.get('displayWidth', 720)
+            screen_height = self.client.u2.info.get('displayHeight', 1280)
+            
+            # 获取元素列表
+            xml_string = self.client.u2.dump_hierarchy()
+            import xml.etree.ElementTree as ET
+            root = ET.fromstring(xml_string)
+            
+            # 关闭按钮特征
+            close_texts = ['×', 'X', 'x', '关闭', '取消', 'close', 'Close', '跳过', '知道了', '我知道了']
+            candidates = []
+            
+            for elem in root.iter():
+                text = elem.attrib.get('text', '')
+                content_desc = elem.attrib.get('content-desc', '')
+                bounds_str = elem.attrib.get('bounds', '')
+                class_name = elem.attrib.get('class', '')
+                clickable = elem.attrib.get('clickable', 'false') == 'true'
+                
+                if not bounds_str:
+                    continue
+                
+                match = re.match(r'\[(\d+),(\d+)\]\[(\d+),(\d+)\]', bounds_str)
+                if not match:
+                    continue
+                
+                x1, y1, x2, y2 = map(int, match.groups())
+                width = x2 - x1
+                height = y2 - y1
+                center_x = (x1 + x2) // 2
+                center_y = (y1 + y2) // 2
+                
+                # 计算百分比
+                x_percent = round(center_x / screen_width * 100, 1)
+                y_percent = round(center_y / screen_height * 100, 1)
+                
+                score = 0
+                reason = ""
+                
+                # 策略1：关闭文本
+                if text in close_texts:
+                    score = 100
+                    reason = f"文本='{text}'"
+                
+                # 策略2：content-desc 包含关闭关键词
+                elif any(kw in content_desc.lower() for kw in ['关闭', 'close', 'dismiss', '跳过']):
+                    score = 90
+                    reason = f"描述='{content_desc}'"
+                
+                # 策略3：小尺寸的 clickable 元素（可能是 X 图标）
+                elif clickable:
+                    min_size = max(20, int(screen_width * 0.03))
+                    max_size = max(120, int(screen_width * 0.12))
+                    if min_size <= width <= max_size and min_size <= height <= max_size:
+                        # 基于位置评分：角落位置加分
+                        rel_x = center_x / screen_width
+                        rel_y = center_y / screen_height
+                        
+                        # 右上角得分最高
+                        if rel_x > 0.6 and rel_y < 0.5:
+                            score = 70 + (rel_x - 0.6) * 50 + (0.5 - rel_y) * 50
+                            reason = f"右上角小元素 {width}x{height}px"
+                        # 左上角
+                        elif rel_x < 0.4 and rel_y < 0.5:
+                            score = 60 + (0.4 - rel_x) * 50 + (0.5 - rel_y) * 50
+                            reason = f"左上角小元素 {width}x{height}px"
+                        # 其他位置的小元素
+                        elif 'Image' in class_name:
+                            score = 50
+                            reason = f"图片元素 {width}x{height}px"
+                        else:
+                            score = 40
+                            reason = f"小型可点击元素 {width}x{height}px"
+                
+                if score > 0:
+                    candidates.append({
+                        'score': score,
+                        'reason': reason,
+                        'bounds': bounds_str,
+                        'center_x': center_x,
+                        'center_y': center_y,
+                        'x_percent': x_percent,
+                        'y_percent': y_percent,
+                        'size': f"{width}x{height}"
+                    })
+            
+            if not candidates:
+                # 没找到，截图让 AI 分析
+                screenshot_result = self.take_screenshot(description="找关闭按钮", compress=True)
+                return {
+                    "success": False,
+                    "message": "❌ 元素树未找到关闭按钮，已截图供 AI 分析",
+                    "screenshot": screenshot_result.get("screenshot_path", ""),
+                    "screen_size": {"width": screen_width, "height": screen_height},
+                    "image_size": {
+                        "width": screenshot_result.get("image_width"),
+                        "height": screenshot_result.get("image_height")
+                    },
+                    "original_size": {
+                        "width": screenshot_result.get("original_img_width"),
+                        "height": screenshot_result.get("original_img_height")
+                    },
+                    "tip": "请分析截图找到 X 关闭按钮，然后调用 mobile_click_by_percent(x_percent, y_percent)"
+                }
+            
+            # 按得分排序
+            candidates.sort(key=lambda x: x['score'], reverse=True)
+            best = candidates[0]
+            
+            return {
+                "success": True,
+                "message": f"✅ 找到可能的关闭按钮",
+                "best_candidate": {
+                    "reason": best['reason'],
+                    "center": {"x": best['center_x'], "y": best['center_y']},
+                    "percent": {"x": best['x_percent'], "y": best['y_percent']},
+                    "bounds": best['bounds'],
+                    "size": best['size'],
+                    "score": best['score']
+                },
+                "click_command": f"mobile_click_by_percent({best['x_percent']}, {best['y_percent']})",
+                "other_candidates": [
+                    {"reason": c['reason'], "percent": f"({c['x_percent']}%, {c['y_percent']}%)", "score": c['score']}
+                    for c in candidates[1:4]
+                ] if len(candidates) > 1 else [],
+                "screen_size": {"width": screen_width, "height": screen_height}
+            }
+            
+        except Exception as e:
+            return {"success": False, "message": f"❌ 查找关闭按钮失败: {e}"}
+    
+    def close_popup(self) -> Dict:
+        """智能关闭弹窗（改进版）
+        
+        核心改进：先检测弹窗区域，再在弹窗范围内查找关闭按钮
+        
+        策略（优先级从高到低）：
+        1. 检测弹窗区域（非全屏的大面积容器）
+        2. 在弹窗边界内查找关闭相关的文本/描述（×、X、关闭、close 等）
+        3. 在弹窗边界内查找小尺寸的 clickable 元素（优先边角位置）
+        4. 如果都找不到，截图让 AI 视觉识别
+        
+        适配策略：
+        - X 按钮可能在任意位置（上下左右都支持）
+        - 使用百分比坐标记录，跨分辨率兼容
+        """
+        try:
+            import re
+            import xml.etree.ElementTree as ET
+            
+            # 获取屏幕尺寸
+            if self._is_ios():
+                return {"success": False, "message": "iOS 暂不支持，请使用截图+坐标点击"}
+            
+            screen_width = self.client.u2.info.get('displayWidth', 720)
+            screen_height = self.client.u2.info.get('displayHeight', 1280)
+            
+            # 获取原始 XML
+            xml_string = self.client.u2.dump_hierarchy()
+            
+            # 关闭按钮的文本特征
+            close_texts = ['×', 'X', 'x', '关闭', '取消', 'close', 'Close', 'CLOSE', '跳过', '知道了']
+            close_desc_keywords = ['关闭', 'close', 'dismiss', 'cancel', '跳过']
+            
+            close_candidates = []
+            popup_bounds = None  # 弹窗区域
+            
+            # 解析 XML
+            try:
+                root = ET.fromstring(xml_string)
+                all_elements = list(root.iter())
+                
+                # ===== 第一步：检测弹窗区域 =====
+                # 弹窗特征：非全屏、面积较大、通常在屏幕中央的容器
+                popup_containers = []
+                for idx, elem in enumerate(all_elements):
+                    bounds_str = elem.attrib.get('bounds', '')
+                    class_name = elem.attrib.get('class', '')
+                    
+                    if not bounds_str:
+                        continue
+                    
+                    match = re.match(r'\[(\d+),(\d+)\]\[(\d+),(\d+)\]', bounds_str)
+                    if not match:
+                        continue
+                    
+                    x1, y1, x2, y2 = map(int, match.groups())
+                    width = x2 - x1
+                    height = y2 - y1
+                    area = width * height
+                    screen_area = screen_width * screen_height
+                    
+                    # 弹窗容器特征：
+                    # 1. 面积在屏幕的 10%-90% 之间（非全屏）
+                    # 2. 宽度或高度不等于屏幕尺寸
+                    # 3. 是容器类型（Layout/View/Dialog）
+                    is_container = any(kw in class_name for kw in ['Layout', 'View', 'Dialog', 'Card', 'Container'])
+                    area_ratio = area / screen_area
+                    is_not_fullscreen = (width < screen_width * 0.98 or height < screen_height * 0.98)
+                    is_reasonable_size = 0.08 < area_ratio < 0.9
+                    
+                    # 排除状态栏区域（y1 通常很小）
+                    is_below_statusbar = y1 > 50
+                    
+                    if is_container and is_not_fullscreen and is_reasonable_size and is_below_statusbar:
+                        popup_containers.append({
+                            'bounds': (x1, y1, x2, y2),
+                            'bounds_str': bounds_str,
+                            'area': area,
+                            'area_ratio': area_ratio,
+                            'idx': idx,  # 元素在 XML 中的顺序（越后越上层）
+                            'class': class_name
+                        })
+                
+                # 选择最可能的弹窗容器（优先选择：XML 顺序靠后 + 面积适中）
+                if popup_containers:
+                    # 按 XML 顺序倒序（后出现的在上层），然后按面积适中程度排序
+                    popup_containers.sort(key=lambda x: (x['idx'], -abs(x['area_ratio'] - 0.3)), reverse=True)
+                    popup_bounds = popup_containers[0]['bounds']
+                
+                # ===== 第二步：在弹窗范围内查找关闭按钮 =====
+                for idx, elem in enumerate(all_elements):
+                    text = elem.attrib.get('text', '')
+                    content_desc = elem.attrib.get('content-desc', '')
+                    bounds_str = elem.attrib.get('bounds', '')
+                    class_name = elem.attrib.get('class', '')
+                    clickable = elem.attrib.get('clickable', 'false') == 'true'
+                    
+                    if not bounds_str:
+                        continue
+                    
+                    # 解析 bounds
+                    match = re.match(r'\[(\d+),(\d+)\]\[(\d+),(\d+)\]', bounds_str)
+                    if not match:
+                        continue
+                    
+                    x1, y1, x2, y2 = map(int, match.groups())
+                    width = x2 - x1
+                    height = y2 - y1
+                    center_x = (x1 + x2) // 2
+                    center_y = (y1 + y2) // 2
+                    
+                    # 如果检测到弹窗区域，检查元素是否在弹窗范围内或附近
+                    in_popup = True
+                    popup_edge_bonus = 0
+                    is_floating_close = False  # 是否是浮动关闭按钮（在弹窗外部上方）
+                    if popup_bounds:
+                        px1, py1, px2, py2 = popup_bounds
+                        
+                        # 关闭按钮可能在弹窗外部（常见设计：X 按钮浮在弹窗右上角外侧）
+                        # 扩大搜索范围：弹窗上方 200 像素，右侧 50 像素
+                        margin_top = 200  # 上方扩展范围（关闭按钮常在弹窗上方）
+                        margin_side = 50  # 左右扩展范围
+                        margin_bottom = 30  # 下方扩展范围
+                        
+                        in_popup = (px1 - margin_side <= center_x <= px2 + margin_side and 
+                                   py1 - margin_top <= center_y <= py2 + margin_bottom)
+                        
+                        # 检查是否是浮动关闭按钮（在弹窗外侧：上方或下方）
+                        # 上方浮动关闭按钮（常见：右上角外侧）
+                        if center_y < py1 and center_y > py1 - margin_top:
+                            if center_x > (px1 + px2) / 2:  # 在弹窗右半部分上方
+                                is_floating_close = True
+                        # 下方浮动关闭按钮（常见：底部中间外侧）
+                        elif center_y > py2 and center_y < py2 + margin_top:
+                            # 下方关闭按钮通常在中间位置
+                            if abs(center_x - (px1 + px2) / 2) < (px2 - px1) / 2:
+                                is_floating_close = True
+                        
+                        if in_popup:
+                            # 计算元素是否在弹窗边缘（关闭按钮通常在边缘）
+                            dist_to_top = abs(center_y - py1)
+                            dist_to_bottom = abs(center_y - py2)
+                            dist_to_left = abs(center_x - px1)
+                            dist_to_right = abs(center_x - px2)
+                            min_dist = min(dist_to_top, dist_to_bottom, dist_to_left, dist_to_right)
+                            
+                            # 在弹窗边缘 100 像素内的元素加分
+                            if min_dist < 100:
+                                popup_edge_bonus = 3.0 * (1 - min_dist / 100)
+                        
+                        # 浮动关闭按钮（在弹窗上方外侧）给予高额加分
+                        if is_floating_close:
+                            popup_edge_bonus += 5.0  # 大幅加分
+                    
+                    if not in_popup:
+                        continue
+                    
+                    # 相对位置（0-1）
+                    rel_x = center_x / screen_width
+                    rel_y = center_y / screen_height
+                    
+                    score = 0
+                    match_type = ""
+                    position = self._get_position_name(rel_x, rel_y)
+                    
+                    # ===== 策略1：精确匹配关闭文本（最高优先级）=====
+                    if text in close_texts:
+                        score = 15.0 + popup_edge_bonus
+                        match_type = f"text='{text}'"
+                    
+                    # ===== 策略2：content-desc 包含关闭关键词 =====
+                    elif any(kw in content_desc.lower() for kw in close_desc_keywords):
+                        score = 12.0 + popup_edge_bonus
+                        match_type = f"desc='{content_desc}'"
+                    
+                    # ===== 策略3：clickable 的小尺寸元素（优先于非 clickable）=====
+                    elif clickable:
+                        min_size = max(20, int(screen_width * 0.03))
+                        max_size = max(120, int(screen_width * 0.15))
+                        if min_size <= width <= max_size and min_size <= height <= max_size:
+                            # clickable 元素基础分更高
+                            base_score = 8.0
+                            # 浮动关闭按钮给予最高分
+                            if is_floating_close:
+                                base_score = 12.0
+                                match_type = "floating_close"
+                            elif 'Image' in class_name:
+                                score = base_score + 2.0
+                                match_type = "clickable_image"
+                            else:
+                                match_type = "clickable"
+                            score = base_score + self._get_position_score(rel_x, rel_y) + popup_edge_bonus
+                    
+                    # ===== 策略4：ImageView/ImageButton 类型的小元素（非 clickable）=====
+                    elif 'Image' in class_name:
+                        min_size = max(15, int(screen_width * 0.02))
+                        max_size = max(120, int(screen_width * 0.12))
+                        if min_size <= width <= max_size and min_size <= height <= max_size:
+                            score = 5.0 + self._get_position_score(rel_x, rel_y) + popup_edge_bonus
+                            match_type = "ImageView"
+                    
+                    # XML 顺序加分（后出现的元素在上层，更可能是弹窗内的元素）
+                    if score > 0:
+                        xml_order_bonus = idx / len(all_elements) * 2.0  # 最多加 2 分
+                        score += xml_order_bonus
+                        
+                        close_candidates.append({
+                            'bounds': bounds_str,
+                            'center_x': center_x,
+                            'center_y': center_y,
+                            'width': width,
+                            'height': height,
+                            'score': score,
+                            'position': position,
+                            'match_type': match_type,
+                            'text': text,
+                            'content_desc': content_desc,
+                            'x_percent': round(rel_x * 100, 1),
+                            'y_percent': round(rel_y * 100, 1),
+                            'in_popup': popup_bounds is not None
+                        })
+                        
+            except ET.ParseError:
+                pass
+            
+            if not close_candidates:
+                # 控件树未找到，自动截全屏图供 AI 分析
+                screenshot_result = self.take_screenshot(description="弹窗全屏", compress=True)
+                
+                # 构建更详细的视觉分析提示
+                visual_hint = "请仔细查看截图，找到关闭按钮（通常是 × 或 X 图标）。"
+                if popup_bounds:
+                    px1, py1, px2, py2 = popup_bounds
+                    visual_hint += f" 弹窗区域大约在 [{px1},{py1}] 到 [{px2},{py2}]，关闭按钮通常在弹窗的右上角或正上方。"
+                else:
+                    visual_hint += " 关闭按钮通常在屏幕右上角、弹窗右上角、或弹窗下方中间位置。"
+                
+                return {
+                    "success": False,
+                    "message": "❌ 控件树未找到关闭按钮，已截全屏图供 AI 视觉分析",
+                    "action_required": visual_hint + " 找到后调用 mobile_click_at_coords(x, y, image_width, image_height, original_img_width, original_img_height) 点击。",
+                    "screenshot": screenshot_result.get("screenshot_path", ""),
+                    "screen_size": {"width": screen_width, "height": screen_height},
+                    "image_size": {
+                        "width": screenshot_result.get("image_width", screen_width),
+                        "height": screenshot_result.get("image_height", screen_height)
+                    },
+                    "original_size": {
+                        "width": screenshot_result.get("original_img_width", screen_width),
+                        "height": screenshot_result.get("original_img_height", screen_height)
+                    },
+                    "popup_detected": popup_bounds is not None,
+                    "popup_bounds": f"[{popup_bounds[0]},{popup_bounds[1]}][{popup_bounds[2]},{popup_bounds[3]}]" if popup_bounds else None,
+                    "search_areas": [
+                        "弹窗右上角（最常见）",
+                        "弹窗正上方外侧（浮动X按钮）",
+                        "弹窗下方中间（某些广告）",
+                        "屏幕右上角"
+                    ],
+                    "button_features": "关闭按钮通常是：小圆形/方形图标、灰色或白色、带有 × 或 X 符号",
+                    "tip": "注意：不要点击广告内容区域，只点击关闭按钮"
+                }
+            
+            # 按得分排序，取最可能的
+            close_candidates.sort(key=lambda x: x['score'], reverse=True)
+            best = close_candidates[0]
+            
+            # 点击
+            self.client.u2.click(best['center_x'], best['center_y'])
+            time.sleep(0.5)
+            
+            # 点击后截图，让 AI 判断是否成功
+            screenshot_result = self.take_screenshot("关闭弹窗后")
+            
+            # 记录操作（使用百分比，跨设备兼容）
+            self._record_operation(
+                'click',
+                x=best['center_x'],
+                y=best['center_y'],
+                x_percent=best['x_percent'],
+                y_percent=best['y_percent'],
+                screen_width=screen_width,
+                screen_height=screen_height,
+                ref=f"close_popup_{best['position']}"
+            )
+            
+            # 返回候选按钮列表，让 AI 看截图判断
+            # 如果弹窗还在，AI 可以选择点击其他候选按钮
+            return {
+                "success": True,
+                "message": f"✅ 已点击关闭按钮 ({best['position']}): ({best['center_x']}, {best['center_y']})",
+                "clicked": {
+                    "position": best['position'],
+                    "match_type": best['match_type'],
+                    "coords": (best['center_x'], best['center_y']),
+                    "percent": (best['x_percent'], best['y_percent'])
+                },
+                "screenshot": screenshot_result.get("screenshot_path", ""),
+                "popup_detected": popup_bounds is not None,
+                "popup_bounds": f"[{popup_bounds[0]},{popup_bounds[1]}][{popup_bounds[2]},{popup_bounds[3]}]" if popup_bounds else None,
+                "other_candidates": [
+                    {
+                        "position": c['position'], 
+                        "type": c['match_type'], 
+                        "coords": (c['center_x'], c['center_y']),
+                        "percent": (c['x_percent'], c['y_percent'])
+                    }
+                    for c in close_candidates[1:4]  # 返回其他3个候选，AI 可以选择
+                ],
+                "tip": "请查看截图判断弹窗是否已关闭。如果弹窗还在，可以尝试点击 other_candidates 中的其他位置；如果误点跳转了，请按返回键"
+            }
+            
+        except Exception as e:
+            return {"success": False, "message": f"❌ 关闭弹窗失败: {e}"}
+    
+    def _get_position_name(self, rel_x: float, rel_y: float) -> str:
+        """根据相对坐标获取位置名称"""
+        if rel_y < 0.4:
+            if rel_x > 0.6:
+                return "右上角"
+            elif rel_x < 0.4:
+                return "左上角"
+            else:
+                return "顶部中间"
+        elif rel_y > 0.6:
+            if rel_x > 0.6:
+                return "右下角"
+            elif rel_x < 0.4:
+                return "左下角"
+            else:
+                return "底部中间"
+        else:
+            if rel_x > 0.6:
+                return "右侧"
+            elif rel_x < 0.4:
+                return "左侧"
+            else:
+                return "中间"
+    
+    def _get_position_score(self, rel_x: float, rel_y: float) -> float:
+        """根据位置计算额外得分（角落位置加分更多）"""
+        # 弹窗关闭按钮常见位置得分：右上角 > 左上角 > 底部中间 > 其他角落
+        if rel_y < 0.4:  # 上半部分
+            if rel_x > 0.6:  # 右上角
+                return 2.0 + (rel_x - 0.6) + (0.4 - rel_y)
+            elif rel_x < 0.4:  # 左上角
+                return 1.5 + (0.4 - rel_x) + (0.4 - rel_y)
+            else:  # 顶部中间
+                return 1.0
+        elif rel_y > 0.6:  # 下半部分
+            if 0.3 < rel_x < 0.7:  # 底部中间
+                return 1.2 + (1 - abs(rel_x - 0.5) * 2)
+            else:  # 底部角落
+                return 0.8
+        else:  # 中间区域
+            return 0.5
+    
     def assert_text(self, text: str) -> Dict:
         """检查页面是否包含文本"""
         try:

{mobile_mcp_ai-2.3.4 → mobile_mcp_ai-2.4.1}/core/ios_client_wda.py

@@ -549,3 +549,8 @@ class IOSClientWDA:
 
 
 
+
+
+
+
+

{mobile_mcp_ai-2.3.4 → mobile_mcp_ai-2.4.1}/mcp_tools/mcp_server.py

@@ -99,7 +99,8 @@ class MobileMCPServer:
     
     async def initialize(self):
         """延迟初始化设备连接"""
-        if self._initialized:
+        # 如果已成功初始化，直接返回
+        if self._initialized and self.tools is not None:
             return
         
         platform = self._detect_platform()
@@ -110,13 +111,13 @@ class MobileMCPServer:
             
             self.client = MobileClient(platform=platform)
             self.tools = BasicMobileToolsLite(self.client)
+            self._initialized = True  # 只在成功时标记
             print(f"📱 已连接到 {platform.upper()} 设备", file=sys.stderr)
         except Exception as e:
-            print(f"⚠️ 设备连接失败: {e}", file=sys.stderr)
-            self.client = type('MockClient', (), {'platform': platform})()
+            print(f"⚠️ 设备连接失败: {e}，下次调用时将重试", file=sys.stderr)
+            self.client = None
             self.tools = None
-        
-        self._initialized = True
+            # 不设置 _initialized = True，下次调用会重试
     
     def _detect_platform(self) -> str:
         """自动检测设备平台"""
@@ -156,19 +157,26 @@ class MobileMCPServer:
         # ==================== 截图（视觉兜底）====================
         tools.append(Tool(
             name="mobile_take_screenshot",
-            description="📸 截图（视觉定位用）。返回截图路径、屏幕尺寸和图片尺寸。\n\n"
+            description="📸 截图（支持全屏和局部裁剪）\n\n"
                        "🎯 使用场景：\n"
                        "- 游戏（Unity/Cocos）无法获取元素时\n"
                        "- mobile_list_elements 返回空时\n"
                        "- 需要确认页面状态时\n\n"
+                       "🔍 【局部裁剪】精确识别小元素（如广告关闭按钮）：\n"
+                       "   1. 先全屏截图，AI 返回大概坐标 (600, 200)\n"
+                       "   2. 再调用 crop_x=600, crop_y=200, crop_size=200 截取局部\n"
+                       "   3. 局部图不压缩，AI 可精确识别\n"
+                       "   4. 点击时传入 crop_offset_x/y 自动换算坐标\n\n"
                        "⚠️ 【重要】截图会被压缩！\n"
-                       "   - screen_width/screen_height = 原始屏幕尺寸\n"
-                       "   - image_width/image_height = 压缩后图片尺寸（AI 看到的）\n"
-                       "   - 点击时必须传入 image_width/image_height 让工具自动转换坐标！",
+                       "   - 全屏截图：点击时传 image_width/image_height 转换坐标\n"
+                       "   - 局部截图：点击时传 crop_offset_x/crop_offset_y 转换坐标",
             inputSchema={
                 "type": "object",
                 "properties": {
-                    "description": {"type": "string", "description": "截图描述（可选）"}
+                    "description": {"type": "string", "description": "截图描述（可选）"},
+                    "crop_x": {"type": "integer", "description": "局部裁剪中心 X 坐标（屏幕坐标，0 表示不裁剪）"},
+                    "crop_y": {"type": "integer", "description": "局部裁剪中心 Y 坐标（屏幕坐标，0 表示不裁剪）"},
+                    "crop_size": {"type": "integer", "description": "裁剪区域大小（推荐 200-400，0 表示不裁剪）"}
                 },
                 "required": []
             }
@@ -218,17 +226,22 @@ class MobileMCPServer:
                        "- 游戏（Unity/Cocos）无法获取元素\n"
                        "- mobile_list_elements 返回空\n"
                        "- 元素没有 id 和 text\n\n"
-                       "⚠️ 【重要】如果坐标来自压缩截图，必须传入 image_width 和 image_height！\n"
-                       "   截图返回的 image_width/image_height 字段就是需要传入的值。\n"
-                       "   工具会自动将图片坐标转换为屏幕坐标。\n\n"
-                       "✅ 自动记录百分比坐标，生成脚本时会转换为跨分辨率兼容的百分比定位",
+                       "⚠️ 【坐标转换】截图返回的参数直接传入：\n"
+                       "   - image_width/image_height: 压缩后尺寸（AI 看到的）\n"
+                       "   - original_img_width/original_img_height: 原图尺寸（用于转换）\n"
+                       "   - crop_offset_x/crop_offset_y: 局部截图偏移\n\n"
+                       "✅ 自动记录百分比坐标，生成脚本时转换为跨分辨率兼容的百分比定位",
             inputSchema={
                 "type": "object",
                 "properties": {
-                    "x": {"type": "number", "description": "X 坐标（像素，来自截图分析或屏幕坐标）"},
-                    "y": {"type": "number", "description": "Y 坐标（像素，来自截图分析或屏幕坐标）"},
-                    "image_width": {"type": "number", "description": "截图的宽度（可选，传入后自动转换坐标）"},
-                    "image_height": {"type": "number", "description": "截图的高度（可选，传入后自动转换坐标）"}
+                    "x": {"type": "number", "description": "X 坐标（来自 AI 分析截图）"},
+                    "y": {"type": "number", "description": "Y 坐标（来自 AI 分析截图）"},
+                    "image_width": {"type": "number", "description": "压缩后图片宽度（截图返回的 image_width）"},
+                    "image_height": {"type": "number", "description": "压缩后图片高度（截图返回的 image_height）"},
+                    "original_img_width": {"type": "number", "description": "原图宽度（截图返回的 original_img_width）"},
+                    "original_img_height": {"type": "number", "description": "原图高度（截图返回的 original_img_height）"},
+                    "crop_offset_x": {"type": "number", "description": "局部截图 X 偏移（裁剪截图时传入）"},
+                    "crop_offset_y": {"type": "number", "description": "局部截图 Y 偏移（裁剪截图时传入）"}
                 },
                 "required": ["x", "y"]
             }
@@ -374,6 +387,48 @@ class MobileMCPServer:
         ))
         
         # ==================== 辅助工具 ====================
+        tools.append(Tool(
+            name="mobile_find_close_button",
+            description="""🔍 智能查找关闭按钮（只找不点，返回位置）
+
+从元素树中找最可能的关闭按钮，返回坐标和百分比位置。
+
+🎯 识别策略（优先级）：
+1. 文本匹配：×、X、关闭、取消、跳过 等
+2. 描述匹配：content-desc 包含 close/关闭
+3. 小尺寸 clickable 元素（右上角优先）
+
+✅ 返回内容：
+- 坐标 (x, y) 和百分比 (x%, y%)
+- 推荐的点击命令：mobile_click_by_percent(x%, y%)
+- 多个候选位置（供确认）
+
+💡 使用流程：
+1. 调用此工具找到关闭按钮位置
+2. 确认位置正确后，用 mobile_click_by_percent 点击
+3. 百分比点击兼容不同分辨率手机""",
+            inputSchema={"type": "object", "properties": {}, "required": []}
+        ))
+        
+        tools.append(Tool(
+            name="mobile_close_popup",
+            description="""🚫 智能关闭弹窗（直接点击）
+
+自动识别并点击关闭按钮，一步完成。
+
+🎯 识别策略：
+1. 文本匹配：×、X、关闭、取消、跳过 等
+2. 描述匹配：content-desc 包含 close/关闭  
+3. ImageView/ImageButton 小元素
+4. clickable 的小尺寸元素（角落位置优先）
+
+⚠️ 如果自动识别失败：
+- 会截图供 AI 分析
+- 用 mobile_find_close_button 先查看候选位置
+- 或用 mobile_click_by_percent 手动点击""",
+            inputSchema={"type": "object", "properties": {}, "required": []}
+        ))
+        
         tools.append(Tool(
             name="mobile_assert_text",
             description="✅ 检查页面是否包含指定文本。用于验证操作结果。",
@@ -444,7 +499,12 @@ class MobileMCPServer:
         try:
             # 截图
             if name == "mobile_take_screenshot":
-                result = self.tools.take_screenshot(arguments.get("description", ""))
+                result = self.tools.take_screenshot(
+                    description=arguments.get("description", ""),
+                    crop_x=arguments.get("crop_x", 0),
+                    crop_y=arguments.get("crop_y", 0),
+                    crop_size=arguments.get("crop_size", 0)
+                )
                 return [TextContent(type="text", text=self.format_response(result))]
             
             elif name == "mobile_get_screen_size":
@@ -457,7 +517,11 @@ class MobileMCPServer:
                     arguments["x"], 
                     arguments["y"],
                     arguments.get("image_width", 0),
-                    arguments.get("image_height", 0)
+                    arguments.get("image_height", 0),
+                    arguments.get("crop_offset_x", 0),
+                    arguments.get("crop_offset_y", 0),
+                    arguments.get("original_img_width", 0),
+                    arguments.get("original_img_height", 0)
                 )
                 return [TextContent(type="text", text=self.format_response(result))]
             
@@ -522,6 +586,14 @@ class MobileMCPServer:
                 result = self.tools.list_elements()
                 return [TextContent(type="text", text=self.format_response(result))]
             
+            elif name == "mobile_find_close_button":
+                result = self.tools.find_close_button()
+                return [TextContent(type="text", text=self.format_response(result))]
+            
+            elif name == "mobile_close_popup":
+                result = self.tools.close_popup()
+                return [TextContent(type="text", text=self.format_response(result))]
+            
             elif name == "mobile_assert_text":
                 result = self.tools.assert_text(arguments["text"])
                 return [TextContent(type="text", text=self.format_response(result))]

{mobile_mcp_ai-2.3.4 → mobile_mcp_ai-2.4.1/mobile_mcp_ai.egg-info}/PKG-INFO

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

{mobile_mcp_ai-2.3.4 → mobile_mcp_ai-2.4.1}/setup.py

@@ -25,7 +25,7 @@ if requirements_file.exists():
 
 setup(
     name="mobile-mcp-ai",
-    version="2.3.4",  # 修复截图坐标偏移问题：支持图片坐标自动转换为屏幕坐标
+    version="2.4.1",  # close_popup改为AI看截图判断是否成功，更智能灵活
     author="douzi",
     author_email="1492994674@qq.com",
     description="移动端自动化 MCP Server - 支持 Android/iOS，AI 功能可选（基础工具不需要 AI）",