重建仓库，重新提交。

.gitignore

@@ -1,15 +1,15 @@
-# ---> Python
 # Byte-compiled / optimized / DLL files
 __pycache__/
+# Python bytecode & caches
+*.pyc
+*.pyo
+*.pyd
 *.py[cod]
 *$py.class
-
+build.bat
-# C extensions
-*.so
 
 # Distribution / packaging
 .Python
-build/
 develop-eggs/
 dist/
 downloads/
@@ -20,12 +20,12 @@ lib64/
 parts/
 sdist/
 var/
-wheels/
-share/python-wheels/
 *.egg-info/
 .installed.cfg
 *.egg
-MANIFEST
+out/
+Main.build/
+Main.dist/
 
 # PyInstaller
 #  Usually these files are written by a python script from a template
@@ -47,10 +47,8 @@ htmlcov/
 nosetests.xml
 coverage.xml
 *.cover
-*.py,cover
 .hypothesis/
 .pytest_cache/
-cover/
 
 # Translations
 *.mo
@@ -71,9 +69,9 @@ instance/
 
 # Sphinx documentation
 docs/_build/
+docs/.doctrees/
 
 # PyBuilder
-.pybuilder/
 target/
 
 # Jupyter Notebook
@@ -84,9 +82,7 @@ profile_default/
 ipython_config.py
 
 # pyenv
-#   For a library or package, you might want to ignore these files since the code is
+.python-version
-#   intended to run in multiple environments; otherwise, check them in:
-# .python-version
 
 # pipenv
 #   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
@@ -95,35 +91,8 @@ ipython_config.py
 #   install all needed dependencies.
 #Pipfile.lock
 
-# UV
+# celery beat schedule file
-#   Similar to Pipfile.lock, it is generally recommended to include uv.lock in version control.
-#   This is especially recommended for binary packages to ensure reproducibility, and is more
-#   commonly ignored for libraries.
-#uv.lock
-
-# poetry
-#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
-#   This is especially recommended for binary packages to ensure reproducibility, and is more
-#   commonly ignored for libraries.
-#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
-#poetry.lock
-
-# pdm
-#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
-#pdm.lock
-#   pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
-#   in version control.
-#   https://pdm.fming.dev/latest/usage/project/#working-with-version-control
-.pdm.toml
-.pdm-python
-.pdm-build/
-
-# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
-__pypackages__/
-
-# Celery stuff
 celerybeat-schedule
-celerybeat.pid
 
 # SageMath parsed files
 *.sage.py
@@ -155,22 +124,9 @@ dmypy.json
 # Pyre type checker
 .pyre/
 
-# pytype static type analyzer
+# pytype static type checker
 .pytype/
 
 # Cython debug symbols
 cython_debug/
-
+build-tidevice.bat
-# PyCharm
-#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
-#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
-#  and can be added to the global gitignore or merged into this file.  For a more nuclear
-#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
-#.idea/
-
-# Ruff stuff:
-.ruff_cache/
-
-# PyPI configuration file
-.pypirc
-

.idea/.gitignore

@@ -0,0 +1,5 @@
+# 默认忽略的文件
+/shelf/
+/workspace.xml
+# 基于编辑器的 HTTP 客户端请求
+/httpRequests/

.idea/IOS__AI.iml

@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<module version="4">
+  <component name="PyDocumentationSettings">
+    <option name="format" value="PLAIN" />
+    <option name="myDocStringFormat" value="Plain" />
+  </component>
+</module>

.idea/git_toolbox_blame.xml

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="GitToolBoxBlameSettings">
+    <option name="version" value="2" />
+  </component>
+</project>

.idea/iOSAI.iml

@@ -0,0 +1,12 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<module type="PYTHON_MODULE" version="4">
+  <component name="NewModuleRootManager">
+    <content url="file://$MODULE_DIR$" />
+    <orderEntry type="inheritedJdk" />
+    <orderEntry type="sourceFolder" forTests="false" />
+  </component>
+  <component name="PyDocumentationSettings">
+    <option name="format" value="PLAIN" />
+    <option name="myDocStringFormat" value="Plain" />
+  </component>
+</module>

.idea/inspectionProfiles/Project_Default.xml

@@ -0,0 +1,22 @@
+<component name="InspectionProjectProfileManager">
+  <profile version="1.0">
+    <option name="myName" value="Project Default" />
+    <inspection_tool class="PyPackageRequirementsInspection" enabled="true" level="WARNING" enabled_by_default="true">
+      <option name="ignoredPackages">
+        <value>
+          <list size="2">
+            <item index="0" class="java.lang.String" itemvalue="numpy" />
+            <item index="1" class="java.lang.String" itemvalue="facebook_wda" />
+          </list>
+        </value>
+      </option>
+    </inspection_tool>
+    <inspection_tool class="PyPep8NamingInspection" enabled="true" level="WEAK WARNING" enabled_by_default="true">
+      <option name="ignoredErrors">
+        <list>
+          <option value="N803" />
+        </list>
+      </option>
+    </inspection_tool>
+  </profile>
+</component>

.idea/inspectionProfiles/profiles_settings.xml

@@ -0,0 +1,6 @@
+<component name="InspectionProjectProfileManager">
+  <settings>
+    <option name="USE_PROJECT_PROFILE" value="false" />
+    <version value="1.0" />
+  </settings>
+</component>

.idea/misc.xml

@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="Black">
+    <option name="sdkName" value="Python 3.12 (AI-IOS)" />
+  </component>
+  <component name="ProjectRootManager" version="2" project-jdk-name="Python 3.12" project-jdk-type="Python SDK" />
+</project>

.idea/modules.xml

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ProjectModuleManager">
+    <modules>
+      <module fileurl="file://$PROJECT_DIR$/.idea/iOSAi.iml" filepath="$PROJECT_DIR$/.idea/iOSAi.iml" />
+    </modules>
+  </component>
+</project>

.idea/vcs.xml

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="VcsDirectoryMappings">
+    <mapping directory="" vcs="Git" />
+  </component>
+</project>

Entity/AnchorModel.py

@@ -0,0 +1,21 @@
+
+# 主播模型
+class AnchorModel:
+    def __init__(self, anchorId= "", country= ""):
+        # 主播ID
+        self.anchorId = anchorId
+        # 主播国家
+        self.country = country
+
+    # 字典转模型
+    @classmethod
+    def dictToModel(cls, d):
+        model = AnchorModel()
+        model.anchorId = d.get('anchorId', "")
+        model.country = d.get('country', "")
+        return model
+
+    # 模型转字典
+    @classmethod
+    def modelToDict(cls, model):
+        return {"anchorId": model.anchorId, "country": model.country}

Entity/DeviceModel.py

@@ -0,0 +1,30 @@
+
+# 设备模型
+class DeviceModel(object):
+    def __init__(self, deviceId, screenPort, width, height, scale, type):
+        super(DeviceModel, self).__init__()
+        # 设备id
+        self.deviceId = deviceId
+        # 投屏端口
+        self.screenPort = screenPort
+        # 屏幕宽度
+        self.width = width
+        # 屏幕高度
+        self.height = height
+        # 物理分辨率和实际分辨率的倍数
+        self.scale = scale
+        # 1 添加 2删除
+        self.type = type
+        self.ready = False
+        self.deleting = False
+
+    # 转字典
+    def toDict(self):
+        return {
+            'deviceId': self.deviceId,
+            'screenPort': self.screenPort,
+            "width": self.width,
+            "height": self.height,
+            "scale": self.scale,
+            'type': self.type
+        }

Entity/ResultData.py

@@ -0,0 +1,16 @@
+import json
+
+# 返回数据模型
+class ResultData(object):
+    def __init__(self, code=200, data=None, message="获取成功"):
+        super(ResultData, self).__init__()
+        self.code = code
+        self.data = data
+        self.message = message
+
+    def toJson(self):
+        return json.dumps({
+            "code": self.code,
+            "data": self.data,
+            "message": self.message
+        }, ensure_ascii=False)  # ensure_ascii=False 确保中文不会被转义

Entity/Variables.py

@@ -0,0 +1,70 @@
+import threading
+from typing import Dict, Any
+from Entity.AnchorModel import AnchorModel
+
+# wda apple bundle id
+WdaAppBundleId = "com.yolojtAgent.wda.xctrunner"
+# WdaAppBundleId = "com.yolozsAgent.wda.xctrunner"
+# wda投屏端口
+wdaScreenPort = 9567
+# wda功能端口
+wdaFunctionPort = 8567
+# 全局主播列表
+anchorList: list[AnchorModel] = []
+# 线程锁
+anchorListLock = threading.Lock()
+# 打招呼数据
+prologueList = {}
+
+# 评论数据
+commentList = []
+
+API_KEY = "app-sdRfZy2by9Kq7uJg7JdOSVr8"
+
+# 本地储存的打招呼数据
+localPrologueList = [
+    "If you are interested in this, you can join our team for a period of time. During this period, if you like our team, you can continue to stay in our team. If you don't like it, you can leave at any time, and you won't lose anything!",
+    "What's even better is that after joining our team, you have no obligations and you don't have to pay me. Everything is free",
+    "I'm from the MARS agency. I noticed that you're very active on TikTok, so I contacted you and hope to become your agent❤",
+    "Hello, can we talk about cooperation and support?",
+    "Hello, I’m a supporter. Can we have a chat?",
+    "Hi 👋 I’m an official TikTok partner. I really enjoy your livestreams. Do you have time to chat about support and cooperation?",
+    "Hello, I really like your livestreams. I’d love to talk about cooperation and also support you.",
+    "Hello, I think you have the potential to become a top streamer. Can we talk?",
+    "Nice to meet you 😊 I watched your livestream and really enjoyed it. Can we chat about cooperation?",
+    "Hello 👋 I’m a livestream team manager. I recently watched your livestream—it’s great 👍 I hope we can talk about how to grow together 💪",
+    "I watched your livestream and would like to invite you to join our team. I’ll reward you with more gifts based on your performance.",
+    "Hello, I’d like to promote your livestream. Can we talk?",
+    "Hello, I think I can help you get more gifts and support for free. Would you be interested in talking with me?",
+    "Hello, I really enjoyed your livestream. Can we chat about cooperation?"
+]
+
+# 评论列表
+commentsList = []
+# 存储主播名和session_id的字典
+anchorWithSession = {}
+# 前端传递的token
+token = ''
+# 前端传递的
+tenantId = 0
+
+userId = 0
+
+
+# 安全删除数据
+def removeModelFromAnchorList(model: AnchorModel):
+    with anchorListLock:
+        anchorList.remove(model)
+
+
+# 添加数据
+def addModelToAnchorList(models: list[Dict[str, Any]]):
+    with anchorListLock:
+        for dic in models:
+            obj = AnchorModel.dictToModel(dic)
+            anchorList.append(obj)
+
+
+# 添加打招呼语
+def addDataToPrologue(data: list[str]):
+    prologueList = data

Module/DeviceInfo.py

@@ -0,0 +1,513 @@
+import json
+import os
+import socket
+import threading
+import time
+import subprocess
+from typing import Dict
+import tidevice
+import wda
+from tidevice import Usbmux, ConnectionType
+from Entity.DeviceModel import DeviceModel
+from Entity.Variables import WdaAppBundleId, wdaFunctionPort
+from Module.FlaskSubprocessManager import FlaskSubprocessManager
+from Module.IOSActivator import IOSActivator
+from Utils.LogManager import LogManager
+
+
+class DeviceInfo:
+    _instance = None
+    _instance_lock = threading.Lock()
+
+    # 离线宽限期（保持你原来的数值）
+    REMOVE_GRACE_SEC = 5.0
+
+    def __new__(cls, *args, **kwargs):
+        if not cls._instance:
+            with cls._instance_lock:
+                if not cls._instance:
+                    cls._instance = super().__new__(cls)
+        return cls._instance
+
+    def __init__(self) -> None:
+        if getattr(self, "_initialized", False):
+            return
+
+        self._lock = threading.RLock()
+        self._models: Dict[str, DeviceModel] = {}
+        self._manager = FlaskSubprocessManager.get_instance()
+        self.screenPort = 9110
+
+        # 设备心跳时间
+        self._last_seen: Dict[str, float] = {}
+
+        # iproxy 子进程：udid -> Popen
+        self._iproxy_process: Dict[str, subprocess.Popen] = {}
+
+        # iproxy HTTP 健康检查失败次数：udid -> 连续失败次数
+        self._iproxy_fail_count: Dict[str, int] = {}
+
+        # Windows 下隐藏子进程窗口（给 iproxy 用）
+        self._creationflags = 0
+        self._startupinfo = None
+        if os.name == "nt":
+            try:
+                # type: ignore[attr-defined]
+                self._creationflags = subprocess.CREATE_NO_WINDOW
+            except Exception:
+                self._creationflags = 0
+
+            si = subprocess.STARTUPINFO()
+            si.dwFlags |= subprocess.STARTF_USESHOWWINDOW
+            si.wShowWindow = 0  # SW_HIDE
+            self._startupinfo = si
+
+        LogManager.info("DeviceInfo 初始化完成", udid="system")
+        print("[Init] DeviceInfo 初始化完成")
+        self._initialized = True
+
+    # ==========================
+    # 主循环
+    # ==========================
+    def listen(self):
+        LogManager.method_info("进入主循环", "listen", udid="system")
+        print("[Listen] 开始监听设备上下线...")
+
+        while True:
+            try:
+                usb = Usbmux().device_list()
+                # 只看 USB 连接的设备
+                online = {d.udid for d in usb if d.conn_type == ConnectionType.USB}
+            except Exception as e:
+                LogManager.warning(f"[device_list] 异常：{e}", udid="system")
+                time.sleep(1)
+                continue
+
+            now = time.time()
+
+            # 当前已知的设备（本轮循环开始时）
+            with self._lock:
+                known = set(self._models.keys())
+                current_count = len(self._models)
+
+            # 1. 处理在线设备
+            for udid in online:
+                # 更新心跳时间
+                self._last_seen[udid] = now
+
+                # 新设备但数量已达上限
+                if udid not in known and current_count >= 6:
+                    print(f"[Add] 设备数量已达 6 台，忽略新设备: {udid}")
+                    LogManager.info(
+                        "[Add] 设备数量已达上限(6)，忽略新设备",
+                        udid=udid,
+                    )
+                    continue
+
+                # 已经在列表里的设备，跳过添加流程
+                if udid in known:
+                    continue
+
+                # 只对新发现的设备做一次信任检查
+                try:
+                    if not self._is_trusted(udid):
+                        LogManager.info(
+                            "[Add] 设备未信任或未就绪，跳过本轮添加",
+                            udid=udid,
+                        )
+                        print(f"[Add] 设备未信任或未就绪，跳过: {udid}")
+                        continue
+                except Exception as e:
+                    LogManager.warning(
+                        f"[Add] 检测设备 {udid} 信任状态异常: {e}",
+                        udid=udid,
+                    )
+                    print(f"[Add] 检测设备 {udid} 信任状态异常: {e}")
+                    continue
+
+                # 二次确认数量上限
+                with self._lock:
+                    if len(self._models) >= 6:
+                        print(f"[Add] 二次检查: 设备数量已达 6 台，忽略新设备: {udid}")
+                        LogManager.info(
+                            "[Add] 二次检查数量上限，忽略新设备",
+                            udid=udid,
+                        )
+                        continue
+
+                # 真正添加设备
+                try:
+                    self._add_device(udid)
+                    current_count += 1
+                except Exception as e:
+                    LogManager.warning(
+                        f"[Add] 处理设备 {udid} 异常: {e}",
+                        udid=udid,
+                    )
+                    print(f"[Add] 处理设备 {udid} 异常: {e}")
+
+            # 2. 处理可能离线的设备（只看本轮开始时 known 里的）
+            for udid in list(known):
+                if udid not in online:
+                    last = self._last_seen.get(udid, 0)
+                    if now - last > self.REMOVE_GRACE_SEC:
+                        try:
+                            self._remove_device(udid)
+                        except Exception as e:
+                            LogManager.method_error(
+                                f"移除失败：{e}",
+                                "listen",
+                                udid=udid,
+                            )
+                            print(f"[Remove] 移除失败 {udid}: {e}")
+
+            # 3. iproxy 看门狗（进程 + HTTP 探活）
+            try:
+                self._check_iproxy_health()
+            except Exception as e:
+                LogManager.warning(
+                    f"[iproxy] 看门狗异常: {e}",
+                    udid="system",
+                )
+                print(f"[iproxy] 看门狗异常: {e}")
+
+            time.sleep(1)
+
+    # 判断设备是否信任
+    def _is_trusted(self, udid: str) -> bool:
+        try:
+            d = tidevice.Device(udid)
+            _ = d.product_version
+            return True
+        except Exception as e:
+            msg = str(e)
+            if "NotTrusted" in msg or "Please trust" in msg or "InvalidHostID" in msg:
+                print(f"[Trust] 设备未信任，udid={udid}, err={msg}")
+                return False
+
+            print(f"[Trust] 检测信任状态出错，当作未信任处理 udid={udid}, err={msg}")
+            return False
+
+    # ==========================
+    # 添加设备
+    # ==========================
+    def _add_device(self, udid: str):
+        with self._lock:
+            if udid in self._models:
+                print(f"[Add] 已存在，跳过: {udid}")
+                return
+            print(f"[Add] 新增设备 {udid}")
+
+        # 判断 iOS 版本
+        try:
+            t = tidevice.Device(udid)
+            version_major = float(t.product_version.split(".")[0])
+        except Exception as e:
+            print(f"[Add] 获取系统版本失败 {udid}: {e}")
+            version_major = 0
+
+        # 分配投屏端口 & 写入模型
+        with self._lock:
+            self.screenPort += 1
+            screen_port = self.screenPort
+
+            model = DeviceModel(
+                deviceId=udid,
+                screenPort=screen_port,
+                width=0,
+                height=0,
+                scale=0,
+                type=1,
+            )
+            self._models[udid] = model
+
+        print(f"[Add] 新设备完成 {udid}, screenPort={screen_port}")
+        self._manager_send()
+
+        # 启动 iproxy（投屏转发）
+        try:
+            self._start_iproxy(udid, screen_port)
+        except Exception as e:
+            print(f"[iproxy] 启动失败 {udid}: {e}")
+            LogManager.warning(f"[iproxy] 启动失败: {e}", udid=udid)
+
+        # 启动 WDA
+        if version_major >= 17.0:
+            threading.Thread(
+                target=IOSActivator().activate_ios17,
+                args=(udid, self._on_wda_ready),
+                daemon=True,
+            ).start()
+        else:
+            try:
+                tidevice.Device(udid).app_start(WdaAppBundleId)
+            except Exception as e:
+                print(f"[Add] 使用 tidevice 启动 WDA 失败 {udid}: {e}")
+                LogManager.warning(
+                    f"[Add] 使用 tidevice 启动 WDA 失败: {e}",
+                    udid=udid,
+                )
+            else:
+                threading.Thread(
+                    target=self._fetch_screen_and_notify,
+                    args=(udid,),
+                    daemon=True,
+                ).start()
+
+    # ==========================
+    # WDA 启动回调（iOS17+）
+    # ==========================
+    def _on_wda_ready(self, udid: str):
+        print(f"[WDA] 回调触发，准备获取屏幕信息 udid={udid}")
+        time.sleep(1)
+        threading.Thread(
+            target=self._fetch_screen_and_notify,
+            args=(udid,),
+            daemon=True,
+        ).start()
+
+    # ==========================
+    # 通过 WDA 获取屏幕信息
+    # ==========================
+    def _screen_info(self, udid: str):
+        try:
+            c = wda.USBClient(udid, wdaFunctionPort)
+            size = c.window_size()
+
+            w = int(size.width)
+            h = int(size.height)
+            s = float(c.scale)
+
+            print(f"[Screen] 成功获取屏幕 {w}x{h} scale={s} {udid}")
+            return w, h, s
+        except Exception as e:
+            print(f"[Screen] 获取屏幕失败: {e} udid={udid}")
+            return 0, 0, 0.0
+
+    # ==========================
+    # 异步获取屏幕尺寸并通知 Flask
+    # ==========================
+    def _fetch_screen_and_notify(self, udid: str):
+        """
+        后台线程里多次尝试通过 WDA 获取屏幕尺寸，
+        成功后更新 model 并发一次 snapshot。
+        """
+        max_retry = 15
+        interval = 1.0
+
+        time.sleep(2.0)
+        for _ in range(max_retry):
+            with self._lock:
+                if udid not in self._models:
+                    print(f"[Screen] 设备已移除，停止获取屏幕信息 udid={udid}")
+                    return
+
+            w, h, s = self._screen_info(udid)
+            if w > 0 and h > 0:
+                with self._lock:
+                    m = self._models.get(udid)
+                    if not m:
+                        print(f"[Screen] 模型已不存在，无法更新 udid={udid}")
+                        return
+                    m.width = w
+                    m.height = h
+                    m.scale = s
+
+                print(f"[Screen] 屏幕信息更新完成，准备推送到 Flask udid={udid}")
+                try:
+                    self._manager_send()
+                except Exception as e:
+                    print(f"[Screen] 发送屏幕更新到 Flask 失败 udid={udid}, err={e}")
+                return
+
+            time.sleep(interval)
+
+        print(f"[Screen] 多次尝试仍未获取到屏幕信息 udid={udid}")
+
+    # ==========================
+    # iproxy 管理
+    # ==========================
+    def _start_iproxy(self, udid: str, local_port: int):
+        iproxy_path = self._find_iproxy()
+
+        p = self._iproxy_process.get(udid)
+        if p is not None and p.poll() is None:
+            print(f"[iproxy] 已存在运行中的进程，跳过 {udid}")
+            return
+
+        args = [
+            iproxy_path,
+            "-u",
+            udid,
+            str(local_port),  # 本地端口（投屏）
+            "9567",           # 手机端口（go-ios screencast）
+        ]
+
+        print(f"[iproxy] 启动进程: {args}")
+
+        proc = subprocess.Popen(
+            args,
+            stdout=subprocess.DEVNULL,
+            stderr=subprocess.DEVNULL,
+            creationflags=self._creationflags,
+            startupinfo=self._startupinfo,
+        )
+
+        self._iproxy_process[udid] = proc
+
+    def _stop_iproxy(self, udid: str):
+        p = self._iproxy_process.get(udid)
+        if not p:
+            return
+        try:
+            p.terminate()
+            try:
+                p.wait(timeout=2)
+            except Exception:
+                p.kill()
+        except Exception:
+            pass
+        self._iproxy_process.pop(udid, None)
+        print(f"[iproxy] 已停止 {udid}")
+
+    def _is_iproxy_http_healthy(self, local_port: int, timeout: float = 1.0) -> bool:
+        """
+        通过向本地 iproxy 转发端口发一个最小的 HTTP 请求，
+        来判断隧道是否“活着”：
+        - 正常：能在超时时间内读到一些 HTTP 头 / 任意字节；
+        - 异常：连接失败、超时、完全收不到字节，都认为不健康。
+        """
+        try:
+            with socket.create_connection(("127.0.0.1", local_port), timeout=timeout) as s:
+                s.settimeout(timeout)
+
+                req = b"GET / HTTP/1.0\r\nHost: 127.0.0.1\r\n\r\n"
+                s.sendall(req)
+
+                data = s.recv(128)
+                if not data:
+                    return False
+
+                if data.startswith(b"HTTP/") or b"\r\n" in data:
+                    return True
+
+                # 即使不是标准 HTTP 头，只要有返回字节，也说明隧道有响应
+                return True
+
+        except (socket.timeout, OSError):
+            return False
+        except Exception:
+            return False
+
+    def _check_iproxy_health(self):
+        """
+        iproxy 看门狗：
+        - 先看进程是否存在 / 已退出；
+        - 再做一次 HTTP 层探活；
+        - 连续多次失败才重启，避免抖动时频繁重启。
+        """
+        with self._lock:
+            items = list(self._models.items())
+
+        for udid, model in items:
+            proc = self._iproxy_process.get(udid)
+
+            # 1) 进程不存在或已退出：直接重启
+            if proc is None or proc.poll() is not None:
+                msg = f"[iproxy] 进程已退出，准备重启 | udid={udid}"
+                print(msg)
+                LogManager.warning(msg, "iproxy")
+
+                self._iproxy_fail_count[udid] = 0
+                try:
+                    self._start_iproxy(udid, model.screenPort)
+                except Exception as e:
+                    msg = f"[iproxy] 重启失败 | udid={udid} | err={e}"
+                    print(msg)
+                    LogManager.warning(msg, "iproxy")
+                continue
+
+            # 2) 进程还在，做一次 HTTP 探活
+            is_ok = self._is_iproxy_http_healthy(model.screenPort)
+
+            if is_ok:
+                if self._iproxy_fail_count.get(udid):
+                    msg = f"[iproxy] HTTP 探活恢复正常 | udid={udid}"
+                    print(msg)
+                    LogManager.info(msg, "iproxy")
+                self._iproxy_fail_count[udid] = 0
+                continue
+
+            # 3) HTTP 探活失败：记录一次失败
+            fail = self._iproxy_fail_count.get(udid, 0) + 1
+            self._iproxy_fail_count[udid] = fail
+
+            msg = f"[iproxy] HTTP 探活失败 {fail} 次 | udid={udid}"
+            print(msg)
+            LogManager.warning(msg, "iproxy")
+
+            FAIL_THRESHOLD = 3
+            if fail >= FAIL_THRESHOLD:
+                msg = f"[iproxy] 连续 {fail} 次 HTTP 探活失败，准备重启 | udid={udid}"
+                print(msg)
+                LogManager.warning(msg, "iproxy")
+
+                self._iproxy_fail_count[udid] = 0
+                try:
+                    self._stop_iproxy(udid)
+                    self._start_iproxy(udid, model.screenPort)
+                except Exception as e:
+                    msg = f"[iproxy] HTTP 探活重启失败 | udid={udid} | err={e}"
+                    print(msg)
+                    LogManager.warning(msg, "iproxy")
+
+    # ==========================
+    # 移除设备
+    # ==========================
+    def _remove_device(self, udid: str):
+        print(f"[Remove] 移除设备 {udid}")
+
+        self._stop_iproxy(udid)
+
+        with self._lock:
+            self._models.pop(udid, None)
+            self._last_seen.pop(udid, None)
+            self._iproxy_fail_count.pop(udid, None)
+
+        self._manager_send()
+
+    # ==========================
+    # 工具方法
+    # ==========================
+    def _find_iproxy(self) -> str:
+        base = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+        name = "iproxy.exe" if os.name == "nt" else "iproxy"
+        return os.path.join(base, "resources", "iproxy", name)
+
+    # ==========================
+    # 同步数据到 Flask
+    # ==========================
+    def _manager_send(self):
+        try:
+            self._send_snapshot_to_flask()
+        except Exception:
+            try:
+                self._manager.start()
+            except Exception:
+                pass
+            try:
+                self._send_snapshot_to_flask()
+            except Exception:
+                pass
+
+    def _send_snapshot_to_flask(self):
+        with self._lock:
+            devices = [m.toDict() for m in self._models.values()]
+
+        payload = json.dumps({"devices": devices}, ensure_ascii=False)
+        port = int(os.getenv("FLASK_COMM_PORT", "34566"))
+
+        with socket.create_connection(("127.0.0.1", port), timeout=1.5) as s:
+            s.sendall(payload.encode() + b"\n")
+
+        print(f"[SNAPSHOT] 已发送 {len(devices)} 台设备")

Module/FlaskService.py

@@ -0,0 +1,887 @@
+# -*- coding: utf-8 -*-
+import json
+import logging
+import os
+import socket
+import threading
+import time
+from pathlib import Path
+from queue import Queue
+from typing import Any, Dict, List
+import anyio
+import wda
+from quart import Quart, request, g
+from quart_cors import cors
+import Entity.Variables as ev
+from Entity import Variables
+from Entity.ResultData import ResultData
+from Entity.Variables import addModelToAnchorList, wdaFunctionPort
+from Utils.AiUtils import AiUtils
+from Utils.ControlUtils import ControlUtils
+from Utils.IOSAIStorage import IOSAIStorage
+from Utils.JsonUtils import JsonUtils
+from Utils.LogManager import LogManager
+from Utils.ThreadManager import ThreadManager
+from script.ScriptManager import ScriptManager
+
+for name in ('werkzeug', 'werkzeug.serving'):
+    log = logging.getLogger(name)
+    log.disabled = True
+    log.propagate = False
+    log.handlers.clear()
+
+app = Quart(__name__)  # ⭐ 这里用 Quart，而不是 Flask
+app = cors(app, allow_origin="*")  # 允许所有来源跨域
+
+app.config['JSON_AS_ASCII'] = False  # Flask jsonify 不转义中文/emoji
+app.config['JSONIFY_MIMETYPE'] = "application/json; charset=utf-8"
+
+# ============ 设备状态内存表 ============
+listData = []
+listLock = threading.Lock()
+
+# 历史遗留：不再消费队列，改为socket线程直接落地
+dataQueue = Queue()
+
+# ---- 黏性快照（避免瞬时空） ----
+_last_nonempty_snapshot = []
+_last_snapshot_ts = 0.0
+_STICKY_TTL_SEC = 10.0  # 在瞬时空时，回退到上一份非空快照10秒
+_empty_logged = False
+_recovered_logged = False
+
+# ===== 设备集合变化跟踪 =====
+change_version = 0
+_device_ids_snapshot = set()
+_last_device_count = 0
+
+def _log_device_changes(action: str):
+    """记录设备集合增删变化"""
+    global _device_ids_snapshot, change_version
+    curr_ids = {d.get("deviceId") for d in listData if _is_online(d)}
+    added = curr_ids - _device_ids_snapshot
+    removed = _device_ids_snapshot - curr_ids
+    if added or removed:
+        change_version += 1
+        try:
+            LogManager.info(f"[DEVICE][CHANGED][{action}] rev={change_version} count={len(curr_ids)} added={list(added)} removed={list(removed)}")
+        except Exception:
+            print(f"[DEVICE][CHANGED][{action}] rev={change_version} count={len(curr_ids)} added={list(added)} removed={list(removed)}")
+        _device_ids_snapshot = curr_ids
+
+def _normalize_type(v) -> int:
+    """把各种表示在线/离线的值，规范成 1/0"""
+    if isinstance(v, bool):
+        return 1 if v else 0
+    if isinstance(v, (int, float)):
+        return 1 if int(v) == 1 else 0
+    if isinstance(v, str):
+        s = v.strip().lower()
+        if s.isdigit():
+            return 1 if int(s) == 1 else 0
+        if s in ("true", "online", "on", "yes"):
+            return 1
+        return 0
+    return 1 if v else 0
+
+def _is_online(d: Dict[str, Any]) -> bool:
+    return _normalize_type(d.get("type", 1)) == 1
+
+def _apply_device_snapshot(devices: List[Dict[str, Any]]):
+    """接收 DeviceInfo 送来的全量设备列表，直接覆盖 listData"""
+    global listData
+    try:
+        normed = []
+        for d in devices:
+            # 拷贝一份，避免引用共享
+            d = dict(d)
+            d["type"] = _normalize_type(d.get("type", 1))  # 规范成 0/1
+            normed.append(d)
+
+        with listLock:
+            before = len(listData)
+            listData[:] = normed  # 全量覆盖
+
+        _log_device_changes("SNAPSHOT")
+        try:
+            LogManager.info(f"[DEVICE][SNAPSHOT] size={len(normed)} (was={before})")
+        except Exception:
+            print(f"[DEVICE][SNAPSHOT] size={len(normed)} (was={before})")
+    except Exception as e:
+        LogManager.error(f"[DEVICE][SNAPSHOT][ERROR] {e}")
+
+def _apply_device_event(obj: Dict[str, Any]):
+    """把单条设备上线/下线事件落到 listData，并打印关键日志"""
+    try:
+        dev_id = obj.get("deviceId")
+        typ = _normalize_type(obj.get("type", 1))
+        obj["type"] = typ  # 写回规范后的值，避免后续被误判
+        if dev_id is None:
+            LogManager.warning(f"[DEVICE][WARN] missing deviceId in obj={obj}")
+            return
+        with listLock:
+            before = len(listData)
+            # 删除同 udid 旧记录
+            listData[:] = [d for d in listData if d.get("deviceId") != dev_id]
+            if typ == 1:
+                listData.append(obj)  # 上线
+                LogManager.info(f"[DEVICE][UPSERT] id={dev_id} type={typ} size={len(listData)} (replaced={before - (len(listData)-1)})")
+                _log_device_changes("UPSERT")
+            else:
+                LogManager.warning(f"[DEVICE][REMOVE] id={dev_id} type={typ} size={len(listData)} (removed_prev={before - len(listData)})")
+                _log_device_changes("REMOVE")
+    except Exception as e:
+        LogManager.error(f"[DEVICE][APPLY_EVT][ERROR] {e}")
+
+# ============ 设备事件 socket 监听 ============
+def _handle_conn(conn: socket.socket, addr):
+    """统一的连接处理函数（拆 JSON 行 → 正常化 type → 应用到 listData）"""
+    try:
+        with conn:
+            try:
+                conn.settimeout(3.0)  # 避免永久阻塞
+            except Exception:
+                pass
+
+            buffer = ""
+            while True:
+                try:
+                    data = conn.recv(1024)
+                    if not data:  # 对端关闭
+                        break
+                    buffer += data.decode('utf-8', errors='ignore')
+
+                    # 按行切 JSON；发送端每条以 '\n' 结尾
+                    while True:
+                        line, sep, buffer = buffer.partition('\n')
+                        if not sep:
+                            break
+                        line = line.strip()
+                        if not line:
+                            continue
+                        try:
+                            obj = json.loads(line)
+                        except json.JSONDecodeError as e:
+                            LogManager.warning(f"[SOCKET][WARN] 非法 JSON 丢弃: {line[:120]}  err={e}")
+                            continue
+
+                        # === 新增：如果是全量快照（包含 devices 字段） ===
+                        if "devices" in obj:
+                            devs = obj.get("devices") or []
+                            LogManager.info(f"[SOCKET][RECV][SNAPSHOT] size={len(devs)} keys={list(obj.keys())}")
+                            try:
+                                _apply_device_snapshot(devs)
+                                LogManager.info(f"[SOCKET][APPLY][SNAPSHOT] size={len(devs)}")
+                            except Exception as e:
+                                LogManager.error(f"[DEVICE][APPLY_SNAPSHOT][ERROR] {e}")
+                            continue  # 处理完这一条，继续下一条 JSON
+
+                        # === 否则按原来的单条设备事件处理（兼容旧逻辑） ===
+                        dev_id = obj.get("deviceId")
+                        typ = _normalize_type(obj.get("type", 1))
+                        obj["type"] = typ  # 规范 1/0
+                        LogManager.info(f"[SOCKET][RECV] deviceId={dev_id} type={typ} keys={list(obj.keys())}")
+
+                        try:
+                            _apply_device_event(obj)  # 保持你原来的增删逻辑
+                            LogManager.info(f"[SOCKET][APPLY] deviceId={dev_id} type={typ}")
+                        except Exception as e:
+                            # 单条业务异常不让线程死
+                            LogManager.error(f"[DEVICE][APPLY_EVT][ERROR] {e}")
+
+                except (socket.timeout, ConnectionResetError, BrokenPipeError):
+                    # 连接级异常：关闭该连接，回到 accept
+                    break
+                except Exception as e:
+                    LogManager.warning(f"[SOCKET][WARN] recv error: {e}")
+                    break
+    except Exception as e:
+        LogManager.error(f"[SOCKET][ERROR] 连接处理异常: {e}")
+
+def start_socket_listener():
+    """启动设备事件监听（仅走 FLASK_COMM_PORT；增强健壮性，不改业务）"""
+    # 统一使用 FLASK_COMM_PORT，默认 34566
+    port = int(os.getenv('FLASK_COMM_PORT', 34566))
+    LogManager.info(f"Received port from environment: {port}")
+    print(f"Received port from environment: {port}")
+
+    if port <= 0:
+        LogManager.info("未获取到通信端口，跳过Socket监听")
+        print("未获取到通信端口，跳过Socket监听")
+        return
+
+    backoff = 0.5  # 自愈退避，起于 0.5s，上限 8s
+    while True:
+        s = None
+        try:
+            s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+            try:
+                s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
+            except Exception as e:
+                LogManager.warning(f"[SOCKET][WARN] setsockopt SO_REUSEADDR failed: {e}")
+
+            try:
+                s.bind(('127.0.0.1', port))
+                print(f"[INFO] Socket successfully bound to port {port}")
+                LogManager.info(f"[INFO] Socket successfully bound to port {port}")
+            except Exception as bind_error:
+                print(f"[ERROR]端口绑定失败: {bind_error}")
+                LogManager.info(f"[ERROR]端口绑定失败: {bind_error}")
+                # 绑定失败通常是端口未释放/竞争，退避后重试
+                time.sleep(backoff)
+                backoff = min(backoff * 2, 8.0)
+                continue
+
+            s.listen(256)
+            try:
+                s.settimeout(1.5)  # accept 超时，便于检查自愈循环
+            except Exception:
+                pass
+
+            LogManager.info(f"[INFO] Socket listener started on port {port}, waiting for connections...")
+            print(f"[INFO] Socket listener started on port {port}, waiting for connections...")
+            # 监听成功 → 退避复位
+            backoff = 0.5
+
+            while True:
+                try:
+                    conn, addr = s.accept()
+                except socket.timeout:
+                    # 定期“透气”，避免永久卡死；继续等待
+                    continue
+                except Exception as e:
+                    # 发生 accept 级错误：重建 socket（进入外层 while 自愈）
+                    LogManager.error(f"[ERROR] accept 失败: {e}")
+                    break
+
+                # 每个连接独立线程处理，保持你原来的做法
+                threading.Thread(target=_handle_conn, args=(conn, addr), daemon=True).start()
+
+        except Exception as e:
+            # 任意未兜住的异常，记录并进入退避自愈
+            LogManager.error(f"[SOCKET][ERROR] 监听主循环异常: {e}")
+            time.sleep(backoff)
+            backoff = min(backoff * 2, 8.0)
+        finally:
+            try:
+                if s:
+                    s.close()
+            except Exception:
+                pass
+
+# 独立线程启动 Socket 服务 + 看门狗
+def bootstrap_server_side_effects():
+    # 仅在真正的 Flask 进程里启动副作用（监听、定时器、MQ 等）
+    listener_thread = threading.Thread(target=start_socket_listener, daemon=True)
+    listener_thread.start()
+
+# 获取app
+def get_app():
+    return app
+
+@app.before_request
+def _log_request_start():
+    g._start_ts = time.time()
+    LogManager.info(
+        text=f"[HTTP] START {request.method} {request.path}",
+        udid="flask"
+    )
+
+@app.after_request
+def _log_request_end(response):
+    cost = time.time() - getattr(g, "_start_ts", time.time())
+    LogManager.info(
+        text=f"[HTTP] END   {request.method} {request.path} {response.status_code} in {cost:.3f}s",
+        udid="flask"
+    )
+    return response
+
+
+# ============ API 路由 ============
+@app.route('/deviceList', methods=['GET'])
+async def deviceList():
+    global _last_device_count, change_version
+    global _last_nonempty_snapshot, _last_snapshot_ts, _STICKY_TTL_SEC
+    global _empty_logged, _recovered_logged
+    try:
+        with listLock:
+            # 宽容判定在线（字符串'1'/'true'/True 都算）
+            data = [d for d in listData if _is_online(d)]
+        now = time.time()
+
+        # 记录最近一次非空快照
+        if data:
+            _last_nonempty_snapshot = data.copy()
+            _last_snapshot_ts = now
+            if _recovered_logged:
+                LogManager.info(f"[API][deviceList][RECOVERED] count={len(data)} rev={change_version}")
+                _recovered_logged = False
+            _empty_logged = False
+        else:
+            # 瞬时空：在 TTL 内回退上一份非空快照
+            if _last_nonempty_snapshot and (now - _last_snapshot_ts) <= _STICKY_TTL_SEC:
+                LogManager.warning(f"[API][deviceList][STICKY] serving last non-empty snapshot count={len(_last_nonempty_snapshot)} age={now - _last_snapshot_ts:.1f}s rev={change_version}")
+                return ResultData(data=_last_nonempty_snapshot).toJson()
+            if not _empty_logged:
+                LogManager.error(f"[API][deviceList][DROP_TO_EMPTY] last_count={_last_device_count} rev={change_version}")
+                _empty_logged = True
+                _recovered_logged = True
+
+        _last_device_count = len(data)
+        LogManager.info(f"[API][deviceList] return_count={len(data)} rev={change_version}")
+        return ResultData(data=data).toJson()
+    except Exception as e:
+        LogManager.error(f"[API][deviceList] error={e}")
+        return ResultData(data=[]).toJson()
+
+@app.route('/passToken', methods=['POST'])
+async def passToken():
+    data = await request.get_json()
+    print(json.dumps(data))
+    return ResultData(data="").toJson()
+
+# 获取设备应用列表
+@app.route('/deviceAppList', methods=['POST'])
+async def deviceAppList():
+    param = await request.get_json()
+    udid = param["udid"]
+    apps = ControlUtils.getDeviceAppList(udid)
+    return ResultData(data=apps).toJson()
+
+# 打开指定app
+@app.route('/launchApp', methods=['POST'])
+async def launchApp():
+    body = await request.get_json()
+    udid = body.get("udid")
+    bundleId = body.get("bundleId")
+    t = wda.USBClient(udid, wdaFunctionPort)
+    t.session().app_start(bundleId)
+    return ResultData(data="").toJson()
+
+# 回到首页
+@app.route('/toHome', methods=['POST'])
+async def toHome():
+    body = await request.get_json()
+    udid = body.get("udid")
+    client = wda.USBClient(udid, wdaFunctionPort)
+    client.home()
+    return ResultData(data="").toJson()
+
+# 点击事件
+@app.route('/tapAction', methods=['POST'])
+async def tapAction():
+    body = await request.get_json()
+    udid = body.get("udid")
+    client = wda.USBClient(udid, wdaFunctionPort)
+    print("-----------------------")
+    print(client)
+    print("-----------------------")
+    session = client.session()
+    session.appium_settings({"snapshotMaxDepth": 0})
+    x = body.get("x")
+    y = body.get("y")
+    session.tap(x, y)
+    return ResultData(data="").toJson()
+
+# 拖拽事件
+@app.route('/swipeAction', methods=['POST'])
+async def swipeAction():
+    body = await request.get_json()
+    udid = body.get("udid")
+    duration = body.get("duration") # 时长
+    sx = body.get("sx") # 起始X点
+    sy = body.get("sy") # 起始Y点
+    ex = body.get("ex") # 结束X点
+    ey = body.get("ey") # 结束Y点
+
+    client = wda.USBClient(udid, wdaFunctionPort)
+    session = client.session()
+    session.appium_settings({"snapshotMaxDepth": 0})
+
+    session.swipe(sx, sy, ex, ey, duration)
+    return ResultData(data="").toJson()
+
+# 长按事件
+@app.route('/longPressAction', methods=['POST'])
+async def longPressAction():
+    body = await request.get_json()
+    udid = body.get("udid")
+    x = body.get("x")
+    y = body.get("y")
+    client = wda.USBClient(udid, wdaFunctionPort)
+    session = client.session()
+    session.appium_settings({"snapshotMaxDepth": 5})
+    session.tap_hold(x, y, 1.0)
+    return ResultData(data="").toJson()
+
+# 养号
+@app.route('/growAccount', methods=['POST'])
+async def growAccount():
+    body = await request.get_json()
+    udid = body.get("udid")
+    Variables.commentList = body.get("comment")
+    isComment = body.get("isComment")
+
+    manager = ScriptManager()
+    event = threading.Event()
+    # 启动脚本
+    thread = threading.Thread(target=manager.growAccount, args=(udid, isComment, event,))
+    # 添加到线程管理
+    code, msg = ThreadManager.add(udid, thread, event)
+    return ResultData(data="", code=code, message=msg).toJson()
+
+# 观看直播
+@app.route("/watchLiveForGrowth", methods=['POST'])
+async def watchLiveForGrowth():
+    body = await request.get_json()
+    udid = body.get("udid")
+    manager = ScriptManager()
+    event = threading.Event()
+    thread = threading.Thread(target=manager.watchLiveForGrowth, args=(udid, event))
+    # 添加到线程管理
+    ThreadManager.add(udid, thread, event)
+    return ResultData(data="").toJson()
+
+# 停止脚本
+@app.route("/stopScript", methods=['POST'])
+async def stopScript():
+    body = await request.get_json()
+    udid = body.get("udid")
+    LogManager.method_info(f"接口收到 /stopScript  udid={udid}", method="task")
+    code, msg = ThreadManager.stop(udid)
+    return ResultData(code=code, data=[], message=msg).toJson()
+
+# 关注打招呼
+@app.route('/passAnchorData', methods=['POST'])
+async def passAnchorData():
+    try:
+        LogManager.method_info("关注打招呼", "关注打招呼")
+        data: Dict[str, Any] = await request.get_json()
+        # 设备列表
+        idList = data.get("deviceList", [])
+        # 主播列表
+        acList = data.get("anchorList", [])
+        Variables.commentList = data.get("comment")
+        isComment = data.get("isComment")
+        LogManager.info(f"[INFO] 获取数据: {idList} {acList}")
+        AiUtils.save_aclist_flat_append(acList)
+        # 是否需要回复
+        needReply = data.get("needReply", False)
+        # 获取打招呼数据
+        ev.prologueList = data.get("prologueList", [])
+        needTranslate = data.get("needTranslate", False)
+
+        # 添加主播数据
+        addModelToAnchorList(acList)
+
+        failed_ids = []
+        # 启动线程，执行脚本（单个设备异常不影响其它设备）
+        for udid in idList:
+            try:
+                manager = ScriptManager()
+                event = threading.Event()
+                thread = threading.Thread(
+                    target=manager.safe_greetNewFollowers,
+                    args=(udid, needReply, isComment, needTranslate, event,),
+                )
+                ThreadManager.add(udid, thread, event)
+            except Exception as e:
+                failed_ids.append(udid)
+                LogManager.error(f"[passAnchorData] 设备 {udid} 启动脚本失败: {e}")
+
+        # 如果所有设备都失败，可以考虑返回错误码
+        if failed_ids and len(failed_ids) == len(idList):
+            return ResultData(
+                data="",
+                code=1001,
+                message=f"所有设备启动失败: {failed_ids}"
+            ).toJson()
+
+        # 部分失败也算整体成功，只是记录一下
+        if failed_ids:
+            LogManager.warning(f"[passAnchorData] 部分设备启动失败: {failed_ids}")
+
+        return ResultData(data="").toJson()
+    except Exception as e:
+        LogManager.error(e)
+        return ResultData(data="", code=1001).toJson()
+
+@app.route('/followAndGreetUnion', methods=['POST'])
+async def followAndGreetUnion():
+    try:
+        LogManager.method_info("关注打招呼", "关注打招呼(联盟号)")
+        data: Dict[str, Any] = await request.get_json()
+
+        # 设备列表
+        idList = data.get("deviceList", [])
+        # 主播列表
+        acList = data.get("anchorList", [])
+        LogManager.info(f"[INFO] 获取数据: {idList} {acList}")
+
+        AiUtils.save_aclist_flat_append(acList)
+
+        # 是否需要回复
+        needReply = data.get("needReply", True)
+        needTranslate = data.get("needTranslate", False)
+        # 获取打招呼数据
+        ev.prologueList = data.get("prologueList", [])
+
+        # 添加主播数据
+        addModelToAnchorList(acList)
+
+        failed_ids = []
+
+        # 启动线程，执行脚本（单个设备异常不影响其它设备）
+        for udid in idList:
+            try:
+                manager = ScriptManager()
+                event = threading.Event()
+                thread = threading.Thread(
+                    target=manager.safe_followAndGreetUnion,
+                    args=(udid, needReply, needTranslate, event),
+                )
+                ThreadManager.add(udid, thread, event)
+            except Exception as e:
+                failed_ids.append(udid)
+                LogManager.error(f"[followAndGreetUnion] 设备 {udid} 启动脚本失败: {e}")
+
+        # 如果所有设备都失败，可以返回错误码
+        if failed_ids and len(failed_ids) == len(idList):
+            return ResultData(
+                data="",
+                code=1001,
+                message=f"所有设备启动失败: {failed_ids}",
+            ).toJson()
+
+        # 部分失败也算整体成功，只是记录一下
+        if failed_ids:
+            LogManager.warning(f"[followAndGreetUnion] 部分设备启动失败: {failed_ids}")
+
+        return ResultData(data="").toJson()
+
+    except Exception as e:
+        LogManager.error(f"[followAndGreetUnion] 接口级异常: {e}")
+        return ResultData(data="", code=1001).toJson()
+
+# 获取私信数据
+@app.route("/getPrologueList", methods=['GET'])
+async def getPrologueList():
+    import Entity.Variables as Variables
+    return ResultData(data=Variables.prologueList).toJson()
+
+# 添加临时数据
+# 批量追加主播到 JSON 文件
+@app.route("/addTempAnchorData", methods=['POST'])
+async def addTempAnchorData():
+    """
+    请求体支持：
+    - 单个对象：{"anchorId": "xxx", "country": "CN"}
+    - 对象数组：[{"anchorId": "xxx", "country": "CN"}, {"anchorId": "yyy", "country": "US"}]
+    """
+    data = await request.get_json()
+    if not data:
+        return ResultData(code=400, message="请求数据为空").toJson()
+    # 追加到 JSON 文件
+    AiUtils.save_aclist_flat_append(data, "data/acList.json")
+    return ResultData(data="ok").toJson()
+
+# 获取当前屏幕上的聊天信息
+@app.route("/getChatTextInfo", methods=['POST'])
+async def getChatTextInfo():
+    data = await request.get_json()
+    udid = data.get("udid")
+    client = wda.USBClient(udid,wdaFunctionPort)
+    session = client.session()
+    xml = session.source()
+    try:
+        result = AiUtils.extract_messages_from_xml(xml)
+
+        last_in = None
+        last_out = None
+
+        for item in reversed(result):  # 从后往前找
+            if item.get('type') != 'msg':
+                continue
+            if last_in is None and item['dir'] == 'in':
+                last_in = item['text']
+            if last_out is None and item['dir'] == 'out':
+                last_out = item['text']
+            if last_in is not None and last_out is not None:
+                break
+
+        print(f"检测出对方的最后一条数据：{last_in},{type(last_in)}")
+        print(f"检测出我的最后一条数据：{last_out},{type(last_out)}")
+
+        return ResultData(data=result).toJson()
+    except Exception as e:
+
+        LogManager.error(f"获取屏幕翻译出现错误：{e}", "获取屏幕翻译")
+
+        data = [
+            {
+                'type': 'massage',
+                'dir': 'in',
+                'text': '当前页面无法获取聊天记录，请在tiktok聊天页面进行获取！！！'
+            },
+            {
+                'type': 'massage',
+                'dir': 'in',
+                'text': 'Unable to retrieve chat messages on the current screen. Please navigate to the TikTok chat page and try again!!!'
+            }
+        ]
+        return ResultData(data=data, message="解析失败").toJson()
+
+# 监控消息
+@app.route("/replyMessages", methods=['POST'])
+async def monitorMessages():
+    LogManager.method_info("开始监控消息，监控消息脚本启动", "监控消息")
+    body = await request.get_json()
+    udid = body.get("udid")
+    # Variables.commentList = body.get("comment")
+
+    manager = ScriptManager()
+    event = threading.Event()
+    thread = threading.Thread(target=manager.replyMessages, args=(udid, event))
+    LogManager.method_info("创建监控消息脚本线程成功", "监控消息")
+    # 添加到线程管理
+    ThreadManager.add(udid, thread, event)
+    return ResultData(data="").toJson()
+
+# 上传日志
+@app.route("/setLoginInfo", methods=['POST'])
+async def upLoadLogLogs():
+    data = await request.get_json()  # 解析 JSON
+    token = data.get("token")
+    userId = data.get("userId")
+    tenantId = data.get("tenantId")
+    ok = LogManager.upload_all_logs("http://47.79.98.113:8101/api/log/upload", token, userId, tenantId)
+    if ok:
+        return ResultData(data="日志上传成功").toJson()
+    else:
+        return ResultData(data="", message="日志上传失败").toJson()
+
+# 获取当前的主播列表数据
+@app.route("/anchorList", methods=['POST'])
+async def queryAnchorList():
+    # 项目根目录（当前文件在 infos 下，回退两层到根目录）
+    root_dir = Path(__file__).resolve().parent.parent
+    file_path = root_dir / "data" / "acList.json"
+
+    data = []
+    if file_path.exists():
+        try:
+            with open(file_path, "r", encoding="utf-8") as f:
+                data = json.load(f)
+        except Exception as e:
+            LogManager.error(f"[anchorList] 读取失败: {e}")
+            data = []
+    return ResultData(data=data).toJson()
+
+# 修改当前的主播列表数据
+@app.route("/updateAnchorList", methods=['POST'])
+async def updateAnchorList():
+    """
+    invitationType: 1 普票 2 金票
+    state: 1 通行(True) / 0 不通行(False)
+    """
+    data = await request.get_json(force=True, silent=True) or {}
+    invitationType = data.get("invitationType")
+    state = bool(data.get("state"))  # 转成布尔
+
+    # 要更新成的值
+    new_status = 1 if state else 0
+
+    # 用工具类解析路径，避免 cwd 影响
+    file_path = AiUtils._resolve_path("data/acList.json")
+
+    # 加载 JSON
+    try:
+        doc = json.loads(file_path.read_text(encoding="utf-8-sig"))
+    except Exception as e:
+        LogManager.error(f"[updateAnchorList] 读取失败: {e}")
+        return ResultData(code=1001, message=f"暂无数据").toJson()
+
+    # 定位 anchorList
+    if isinstance(doc, list):
+        acList = doc
+        wrapper = None
+    elif isinstance(doc, dict) and isinstance(doc.get("anchorList"), list):
+        acList = doc["anchorList"]
+        wrapper = doc
+    else:
+        return ResultData(code=500, message="文件格式不合法").toJson()
+
+    # 遍历并更新
+    updated = 0
+    for item in acList:
+        if isinstance(item, dict) and item.get("invitationType") == invitationType:
+            item["state"] = new_status
+            updated += 1
+
+    # 写回（保持原始结构）
+    try:
+        file_path.parent.mkdir(parents=True, exist_ok=True)
+        to_write = wrapper if wrapper is not None else acList
+        file_path.write_text(json.dumps(to_write, ensure_ascii=False, indent=2), encoding="utf-8")
+    except Exception as e:
+        LogManager.error(f"[updateAnchorList] 写入失败: {e}")
+        return ResultData(code=500, message=f"写入失败: {e}").toJson()
+
+    if updated:
+        return ResultData(data=updated, message=f"已更新 {updated} 条记录").toJson()
+    else:
+        return ResultData(data=0, message="未找到符合条件的记录").toJson()
+
+# 删除主播
+@app.route("/deleteAnchorWithIds", methods=['POST'])
+async def deleteAnchorWithIds():
+    ls: list[dict] = await request.get_json()  # [{"anchorId": "xxx"}, ...]
+    ids = [d.get("anchorId") for d in ls if d.get("anchorId")]
+    deleted = AiUtils.delete_anchors_by_ids(ids)
+    return ResultData(data={"deleted": deleted}).toJson()
+
+# 配置ai人设
+@app.route("/aiConfig", methods=['POST'])
+async def aiConfig():
+    data = await request.get_json()
+    agentName = data.get("agentName")
+    guildName = data.get("guildName")
+    contactTool = data.get("contactTool")
+    contact = data.get("contact")
+
+    age = data.get("age")
+    sex = data.get("sex")
+    height = data.get("height")
+    weight = data.get("weight")
+    body_features = data.get("body_features")
+    nationality = data.get("nationality")
+    personality = data.get("personality")
+    strengths = data.get("strengths")
+
+    dict = {
+        "agentName": agentName,
+        "guildName": guildName,
+        "contactTool": contactTool,
+        "contact": contact,
+        "age": age,
+        "sex": sex,
+        "height": height,
+        "weight": weight,
+        "body_features": body_features,
+        "nationality": nationality,
+        "personality": personality,
+        "strengths": strengths,
+        "api-key": "app-sdRfZy2by9Kq7uJg7JdOSVr8"
+    }
+
+    # JsonUtils.write_json("aiConfig", dict)
+    IOSAIStorage.overwrite(dict, "aiConfig.json")
+    return ResultData(data="").toJson()
+
+# 查询主播聊天发送的最后一条信息
+@app.route("/select_last_message", methods=['GET'])
+async def select_last_message():
+    data = JsonUtils.query_all_json_items()
+    return ResultData(data=data).toJson()
+
+#  修改消息（已读改成未读）
+@app.route("/update_last_message", methods=['POST'])
+async def update_last_message():
+    data = await request.get_json()  # 解析 JSON
+    sender = data.get("sender")
+    udid = data.get("device")
+    text = data.get("text")
+
+    updated_count = JsonUtils.update_json_items(
+        match={"sender": sender, "text": text},  # 匹配条件
+        patch={"status": 1},  # 修改内容
+        filename="log/last_message.json",  # 要修改的文件
+        multi=True  # 只改第一条匹配的
+    )
+    if updated_count > 0:
+        return ResultData(data=updated_count, message="修改成功").toJson()
+    return ResultData(data=updated_count, message="修改失败").toJson()
+
+# 删除已读消息
+@app.route("/delete_last_message", methods=['POST'])
+async def delete_last_message():
+    data = await request.get_json()  # 解析 JSON
+    sender = data.get("sender")
+    udid = data.get("device")
+    text = data.get("text")
+
+    updated_count = JsonUtils.delete_json_items(
+        match={"sender": sender, "text": text},  # 匹配条件
+        filename="log/last_message.json",  # 要修改的文件
+        multi=True  # 只改第一条匹配的
+    )
+    if updated_count > 0:
+        return ResultData(data=updated_count, message="修改成功").toJson()
+
+    return ResultData(data=updated_count, message="修改失败").toJson()
+
+# 停止所有任务
+@app.route("/stopAllTask", methods=['POST'])
+async def stopAllTask():
+    idList = await request.get_json()
+    code, msg, data = ThreadManager.batch_stop(idList)
+    return ResultData(code, data, msg).toJson()
+
+# 切换账号
+@app.route('/changeAccount', methods=['POST'])
+async def changeAccount():
+    body = await request.get_json()
+    udid = body.get("udid")
+    if not udid:
+        return ResultData(data="", code=400, message="缺少 udid").toJson()
+
+    manager = ScriptManager()
+    threading.Event()
+
+    # 启动脚本
+    code, msg = manager.changeAccount(udid)
+    # thread = threading.Thread(target=, args=(udid,))
+    # # 添加到线程管理
+    # thread.start()
+    return ResultData(data="", code=code, message=msg).toJson()
+
+# 查看设备网络状态
+@app.route('/getDeviceNetStatus', methods=['POST'])
+async def getDeviceNetStatus():
+    body = await request.get_json()
+    udid = body.get("udid")
+    # 同步且超级慢的逻辑 → 丢到线程池，不阻塞事件循环
+    def _work():
+        client = wda.USBClient(udid, wdaFunctionPort)
+        r = client.getNetWorkStatus()
+        return r.get("value")
+    value = await anyio.to_thread.run_sync(_work)
+
+    return ResultData(data=value, code=200).toJson()
+
+# 获取ai配置
+@app.route("/getAiConfig", methods=['GET'])
+def getAiConfig():
+    data = IOSAIStorage.load("aiConfig.json")
+    return ResultData(data=data).toJson()
+
+# 重新开启tiktok
+@app.route("/restartTikTok", methods=['POST'])
+async def restartTikTok():
+    json = await request.get_json()
+    udid = json.get("udid")
+    client = wda.USBClient(udid, wdaFunctionPort)
+    session = client.session()
+    ControlUtils.closeTikTok(session, udid)
+    time.sleep(1)
+    ControlUtils.openTikTok(session, udid)
+    return ResultData(data="").toJson()
+
+# 健康检查
+@app.get("/health")
+async def health():
+    return {"status": "ok"}
+
+if __name__ == '__main__':
+    # 只有“明确是 Flask 进程”才跑副作用（通过 APP_ROLE 控制）
+    app.run("0.0.0.0", port=5000, debug=False, use_reloader=False, threaded=True)

Module/FlaskSubprocessManager.py

@@ -0,0 +1,270 @@
+# -*- coding: utf-8 -*-
+import atexit
+import json
+import os
+import socket
+import subprocess
+import sys
+import threading
+import time
+from pathlib import Path
+from typing import Optional, Union, Dict, List
+
+from Utils.LogManager import LogManager
+
+
+class FlaskSubprocessManager:
+    """
+    超稳定版 Flask 子进程守护
+    - 单线程 watchdog（唯一监控点）
+    - 强制端口检测
+    - 端口不通 / 子进程退出 → 100% 重启
+    - 完整支持 exe + Python 模式
+    - 自动恢复设备列表快照
+    """
+
+    _instance = None
+    _lock = threading.RLock()
+
+    def __new__(cls):
+        with cls._lock:
+            if cls._instance is None:
+                cls._instance = super().__new__(cls)
+                cls._instance._initialize()
+            return cls._instance
+
+    # ========================= 初始化 =========================
+    def _initialize(self):
+        self.process: Optional[subprocess.Popen] = None
+        self.comm_port = 34566
+        self._watchdog_running = False
+        self._stop_event = threading.Event()
+
+        self._restart_cooldown = 5            # 每次重启最少间隔
+        self._restart_fail_threshold = 3      # 端口检查连续失败几次才重启
+        self._restart_fail_count = 0
+
+        self._restart_window = 600            # 10 分钟
+        self._restart_limit = 5               # 最多次数
+        self._restart_record: List[float] = []
+
+        if os.name == "nt":
+            si = subprocess.STARTUPINFO()
+            si.dwFlags |= subprocess.STARTF_USESHOWWINDOW
+            si.wShowWindow = 0
+            self._si = si
+        else:
+            self._si = None
+
+        atexit.register(self.stop)
+        self._kill_orphans()
+
+        LogManager.info("FlaskSubprocessManager 初始化完成", udid="flask")
+
+    # ========================= 工具 =========================
+    def _log(self, level, msg):
+        print(msg)
+        if level == "info":
+            LogManager.info(msg, udid="flask")
+        elif level == "warn":
+            LogManager.warning(msg, udid="flask")
+        else:
+            LogManager.error(msg, udid="flask")
+
+    # 杀死残留 python.exe 占用端口
+    def _kill_orphans(self):
+        try:
+            if os.name == "nt":
+                out = subprocess.check_output(["netstat", "-ano"], text=True)
+                for line in out.splitlines():
+                    if f"127.0.0.1:{self.comm_port}" in line and "LISTENING" in line:
+                        pid = int(line.strip().split()[-1])
+                        if pid != os.getpid():
+                            subprocess.run(
+                                ["taskkill", "/F", "/PID", str(pid)],
+                                capture_output=True
+                            )
+                            self._log("warn", f"[FlaskMgr] 杀死残留 Flask 实例 PID={pid}")
+        except Exception:
+            pass
+
+    def _port_alive(self):
+        """检测 Flask 与 Quart 的两个端口是否活着"""
+        def _check(p):
+            try:
+                with socket.create_connection(("127.0.0.1", p), timeout=0.4):
+                    return True
+            except Exception:
+                return False
+
+        return _check(self.comm_port) or _check(self.comm_port + 1)
+
+    # ========================= 启动 =========================
+    # ========================= 启动 =========================
+    def start(self):
+        with self._lock:
+            # 已经有一个在跑了就别重复起
+            if self.process and self.process.poll() is None:
+                self._log("warn", "[FlaskMgr] Flask 已在运行，跳过")
+                return
+
+            # 设定环境变量，给子进程用
+            env = os.environ.copy()
+            env["FLASK_COMM_PORT"] = str(self.comm_port)
+
+            # ✅ 正确判断是否是 Nuitka/打包后的 exe
+            #   - 被 Nuitka 打包：sys.frozen 会存在/为 True
+            #   - 直接用 python 跑 .py：sys.frozen 不存在
+            is_frozen = bool(getattr(sys, "frozen", False))
+
+            if is_frozen:
+                # 打包后的 exe 模式：直接调用自己
+                exe = Path(sys.executable).resolve()
+                cmd = [str(exe), "--role=flask"]
+                cwd = str(exe.parent)
+            else:
+                # 开发模式：用 python 去跑 Module/Main.py --role=flask
+                project_root = Path(__file__).resolve().parents[1]
+                main_py = project_root / "Module" / "Main.py"
+                cmd = [sys.executable, "-u", str(main_py), "--role=flask"]
+                cwd = str(project_root)
+
+            self._log("info", f"[FlaskMgr] 启动 Flask: {cmd}")
+
+            self.process = subprocess.Popen(
+                cmd,
+                stdout=subprocess.PIPE,
+                stderr=subprocess.STDOUT,
+                text=True,
+                env=env,
+                cwd=cwd,
+                bufsize=1,
+                startupinfo=self._si,
+                start_new_session=True,
+            )
+
+            # 异步吃子进程 stdout，顺便打日志
+            threading.Thread(target=self._read_stdout, daemon=True).start()
+
+            # 看门狗只需要起一次
+            if not self._watchdog_running:
+                threading.Thread(target=self._watchdog_loop, daemon=True).start()
+                self._watchdog_running = True
+
+            self._log("info", f"[FlaskMgr] Flask 子进程已启动 PID={self.process.pid}")
+
+    def _read_stdout(self):
+        if not self.process or not self.process.stdout:
+            return
+        for line in iter(self.process.stdout.readline, ""):
+            if line:
+                self._log("info", f"[Flask] {line.rstrip()}")
+
+    # ========================= 停止 =========================
+    def stop(self):
+        with self._lock:
+            if not self.process:
+                return
+
+            try:
+                self.process.terminate()
+            except Exception:
+                pass
+
+            try:
+                self.process.wait(timeout=3)
+            except Exception:
+                pass
+
+            if self.process.poll() is None:
+                try:
+                    self.process.kill()
+                except Exception:
+                    pass
+
+            self._log("warn", "[FlaskMgr] 已停止 Flask 子进程")
+            self.process = None
+
+    # ========================= 看门狗 =========================
+    def _watchdog_loop(self):
+        self._log("info", "[FlaskWD] 看门狗已启动")
+
+        while not self._stop_event.is_set():
+            time.sleep(1.2)
+
+            # 1) 子进程退出
+            if not self.process or self.process.poll() is not None:
+                self._log("error", "[FlaskWD] Flask 子进程退出，准备重启")
+                self._restart()
+                continue
+
+            # 2) 端口不通
+            if not self._port_alive():
+                self._restart_fail_count += 1
+                self._log("warn", f"[FlaskWD] 端口检测失败 {self._restart_fail_count}/"
+                                  f"{self._restart_fail_threshold}")
+
+                if self._restart_fail_count >= self._restart_fail_threshold:
+                    self._restart()
+                continue
+
+            # 3) 端口正常
+            self._restart_fail_count = 0
+
+    # ========================= 重启核心逻辑 =========================
+    def _restart(self):
+        now = time.time()
+
+        # 10 分钟限频
+        self._restart_record = [t for t in self._restart_record if now - t < self._restart_window]
+        if len(self._restart_record) >= self._restart_limit:
+            self._log("error", "[FlaskWD] 10 分钟内重启次数太多，暂停监控")
+            return
+
+        # 冷却
+        if self._restart_record and now - self._restart_record[-1] < self._restart_cooldown:
+            self._log("warn", "[FlaskWD] 冷却中，暂不重启")
+            return
+
+        self._log("warn", "[FlaskWD] >>> 重启 Flask 子进程 <<<")
+
+        # 执行重启
+        try:
+            self.stop()
+            time.sleep(1)
+            self.start()
+            self._restart_record.append(now)
+            self._restart_fail_count = 0
+        except Exception as e:
+            self._log("error", f"[FlaskWD] 重启失败: {e}")
+
+        # 重启后推送设备快照
+        self._push_snapshot()
+
+    # ========================= 推送设备快照 =========================
+    def _push_snapshot(self):
+        """Flask 重启后重新同步 DeviceInfo 内容"""
+        try:
+            from Module.DeviceInfo import DeviceInfo
+            info = DeviceInfo()
+            with info._lock:
+                for m in info._models.values():
+                    self.send(m.toDict())
+        except Exception:
+            pass
+
+    # ========================= 发送数据 =========================
+    def send(self, data: Union[str, Dict]):
+        if isinstance(data, dict):
+            data = json.dumps(data, ensure_ascii=False)
+
+        try:
+            with socket.create_connection(("127.0.0.1", self.comm_port), timeout=2) as s:
+                s.sendall((data + "\n").encode())
+            return True
+        except Exception:
+            return False
+
+    @classmethod
+    def get_instance(cls):
+        return cls()

Module/IOSActivator.py

@@ -0,0 +1,355 @@
+import os
+import sys
+import time
+import threading
+import subprocess
+from typing import Optional, Callable
+
+from Entity.Variables import WdaAppBundleId
+
+
+class IOSActivator:
+    """
+    给 iOS17+ 用的 go-ios 激活器（单例）：
+      - 维护一条全局 tunnel 进程
+      - 流程：tunnel start -> pair(可多次重试) -> image auto(非致命) -> runwda(多次重试+日志判定成功)
+      - WDA 启动成功后触发回调 on_wda_ready(udid)
+    """
+
+    # ===== 单例 & 全局 tunnel =====
+    _instance = None
+    _instance_lock = threading.Lock()
+
+    _tunnel_proc: Optional[subprocess.Popen] = None
+    _tunnel_lock = threading.Lock()
+
+    def __new__(cls, *args, **kwargs):
+        with cls._instance_lock:
+            if cls._instance is None:
+                cls._instance = super().__new__(cls)
+        return cls._instance
+
+    def __init__(
+            self,
+            ios_path: Optional[str] = None,
+            pair_timeout: int = 60,  # 配对最多等多久
+            pair_retry_interval: int = 3,  # 配对重试间隔
+            runwda_max_retry: int = 10,  # runwda 最大重试次数
+            runwda_retry_interval: int = 3,  # runwda 重试间隔
+            runwda_wait_timeout: int = 25  # 单次 runwda 等待“成功日志”的超时时间
+    ):
+        if getattr(self, "_inited", False):
+            return
+
+        # 运行路径处理（源码 / Nuitka EXE）
+        if "__compiled__" in globals():
+            base_dir = os.path.dirname(sys.executable)
+        else:
+            cur_file = os.path.abspath(__file__)
+            base_dir = os.path.dirname(os.path.dirname(cur_file))
+
+        resource_dir = os.path.join(base_dir, "resources")
+        if not ios_path:
+            ios_path = os.path.join(resource_dir, "ios.exe")
+
+        self.ios_path = ios_path
+        self.pair_timeout = pair_timeout
+        self.pair_retry_interval = pair_retry_interval
+        self.runwda_max_retry = runwda_max_retry
+        self.runwda_retry_interval = runwda_retry_interval
+        self.runwda_wait_timeout = runwda_wait_timeout
+
+        self._lock = threading.Lock()
+
+        # ========= 关键：这里改成“真正隐藏窗口”的安全版 =========
+        self._creationflags = 0
+        self._startupinfo = None
+        if os.name == "nt":
+            try:
+                # 只用 CREATE_NO_WINDOW，不搞 DETACHED_PROCESS / NEW_PROCESS_GROUP 之类的骚操作
+                self._creationflags = subprocess.CREATE_NO_WINDOW  # type: ignore[attr-defined]
+            except Exception:
+                self._creationflags = 0
+
+            si = subprocess.STARTUPINFO()
+            try:
+                si.dwFlags |= subprocess.STARTF_USESHOWWINDOW  # type: ignore[attr-defined]
+            except Exception:
+                # 某些极端环境下可能没有 STARTF_USESHOWWINDOW，忽略即可
+                pass
+            si.wShowWindow = 0  # SW_HIDE
+            self._startupinfo = si
+        # ========= 关键部分结束 =========
+
+        self._inited = True
+
+    # ===== 通用同步命令执行 =====
+    def _run(
+        self,
+        args,
+        desc: str = "",
+        timeout: Optional[int] = None,
+        check: bool = True,
+    ):
+        cmd = [self.ios_path] + list(args)
+        cmd_str = " ".join(cmd)
+        if desc:
+            print(f"[ios] 执行命令({desc}): {cmd_str}")
+        else:
+            print(f"[ios] 执行命令: {cmd_str}")
+
+        try:
+            proc = subprocess.run(
+                cmd,
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE,
+                text=True,
+                timeout=timeout,
+                creationflags=self._creationflags,
+                startupinfo=self._startupinfo,
+            )
+        except subprocess.TimeoutExpired:
+            if check:
+                raise
+            return -1, "", "timeout"
+
+        out = proc.stdout or ""
+        err = proc.stderr or ""
+        if check and proc.returncode != 0:
+            print(f"[ios] 命令失败({desc}), rc={proc.returncode}")
+            raise RuntimeError(f"[ios] 命令失败({desc}), returncode={proc.returncode}")
+
+        return proc.returncode, out, err
+
+    # ===== tunnel 相关 =====
+    def _drain_process_output(self, proc: subprocess.Popen, name: str):
+        """吃掉后台进程输出，防止缓冲区阻塞"""
+        try:
+            if proc.stdout:
+                for line in proc.stdout:
+                    line = line.rstrip()
+                    if line:
+                        print(f"[ios][{name}] {line}")
+        except Exception as e:
+            print(f"[ios][{name}] 读取 stdout 异常: {e}")
+
+        try:
+            if proc.stderr:
+                for line in proc.stderr:
+                    line = line.rstrip()
+                    if line:
+                        print(f"[ios][{name}][stderr] {line}")
+        except Exception as e:
+            print(f"[ios][{name}] 读取 stderr 异常: {e}")
+
+    def _spawn_tunnel(self):
+        """启动 / 复用全局 tunnel（不隐藏窗口）"""
+        with IOSActivator._tunnel_lock:
+            # 已有并且还在跑就复用
+            if IOSActivator._tunnel_proc is not None and IOSActivator._tunnel_proc.poll() is None:
+                print("[ios] tunnel 已经在运行，跳过重新启动")
+                return
+
+            cmd = [self.ios_path, "tunnel", "start"]
+            print("[ios] 启动 go-ios tunnel:", " ".join(cmd))
+            try:
+                proc = subprocess.Popen(
+                    cmd,
+                    stdout=subprocess.PIPE,
+                    stderr=subprocess.PIPE,
+                    text=True,
+                    creationflags=self._creationflags,  # 0：不隐藏
+                    startupinfo=self._startupinfo,      # None：不隐藏
+                )
+            except Exception as e:
+                print("[ios] 启动 tunnel 失败(忽略):", e)
+                return
+
+            IOSActivator._tunnel_proc = proc
+            print("[ios] tunnel 启动成功, PID=", proc.pid)
+
+            # 后台吃日志
+            threading.Thread(
+                target=self._drain_process_output,
+                args=(proc, "tunnel"),
+                daemon=True,
+            ).start()
+
+    # ===== pair & image =====
+    def _pair_until_success(self, udid: str):
+        deadline = time.time() + self.pair_timeout
+        attempt = 0
+
+        while True:
+            attempt += 1
+            print(f"[ios] 开始配对设备({udid})，第 {attempt} 次尝试")
+
+            rc, out, err = self._run(
+                ["--udid", udid, "pair"],
+                desc=f"pair({udid})",
+                timeout=20,
+                check=False,
+            )
+
+            text = (out or "") + "\n" + (err or "")
+            # 打印一份完整输出，方便调试
+            if text.strip():
+                print("[ios][pair] output:\n", text.strip())
+
+            if "Successfully paired" in text:
+                print(f"[ios] 设备 {udid} 配对成功")
+                return
+
+            if time.time() >= deadline:
+                raise RuntimeError(f"[ios] 设备 {udid} 在超时时间内配对失败(rc={rc})")
+
+            time.sleep(self.pair_retry_interval)
+
+    def _mount_dev_image(self, udid: str):
+        print(f"[ios] 开始为设备 {udid} 挂载开发者镜像 (image auto)")
+        rc, out, err = self._run(
+            ["--udid", udid, "image", "auto"],
+            desc=f"image auto({udid})",
+            timeout=300,
+            check=False,
+        )
+
+        text = (out or "") + "\n" + (err or "")
+        text_lower = text.lower()
+        success_keywords = [
+            "success mounting image",
+            "there is already a developer image mounted",
+        ]
+        if any(k in text_lower for k in success_keywords):
+            print(f"[ios] 设备 {udid} 开发者镜像挂载完成")
+            if text.strip():
+                print("[ios][image auto] output:\n", text.strip())
+            return
+
+        print(f"[ios] 设备 {udid} 挂载开发者镜像可能失败(rc={rc})，输出:\n{text.strip()}")
+
+    # ===== runwda（关键逻辑） =====
+    def _run_wda_once_async(self, udid: str, on_wda_ready: Optional[Callable[[str], None]]) -> bool:
+        """
+        单次 runwda：
+          - 异步启动 ios.exe
+          - 实时读 stdout/stderr
+          - 捕获关键日志（got capabilities / authorized true）视为成功
+          - 超时/进程退出且未成功 -> 失败
+        """
+        cmd = [
+            self.ios_path,
+            f"--udid={udid}",
+            "runwda",
+            f"--bundleid={WdaAppBundleId}",
+            f"--testrunnerbundleid={WdaAppBundleId}",
+            "--xctestconfig=yolo.xctest",
+        ]
+        print("[ios] 异步启动 runwda:", " ".join(cmd))
+
+        try:
+            proc = subprocess.Popen(
+                cmd,
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE,
+                text=True,
+                creationflags=self._creationflags,  # 0：不隐藏
+                startupinfo=self._startupinfo,
+            )
+        except Exception as e:
+            print(f"[ios] 启动 runwda 进程失败: {e}")
+            return False
+
+        success_evt = threading.Event()
+
+        def _reader(pipe, tag: str):
+            try:
+                for raw in pipe:
+                    line = (raw or "").rstrip()
+                    if not line:
+                        continue
+                    print(f"[WDA-LOG] {line}")
+                    lower = line.lower()
+                    # 你实测的“成功特征”
+                    if "got capabilities" in lower or '"authorized":true' in lower:
+                        success_evt.set()
+                        print(f"[ios] 捕获到 WDA 启动成功日志({tag})，udid={udid}")
+                        break
+            except Exception as e:
+                print(f"[ios] 读取 {tag} 日志异常: {e}")
+
+        # 日志线程
+        if proc.stdout:
+            threading.Thread(target=_reader, args=(proc.stdout, "stdout"), daemon=True).start()
+        if proc.stderr:
+            threading.Thread(target=_reader, args=(proc.stderr, "stderr"), daemon=True).start()
+
+        # 等待成功 / 退出 / 超时
+        start = time.time()
+        while True:
+            if success_evt.is_set():
+                print(f"[ios] WDA 日志确认已启动，udid={udid}")
+                if on_wda_ready:
+                    try:
+                        on_wda_ready(udid)
+                    except Exception as e:
+                        print(f"[WDA] 回调执行异常: {e}")
+                # 不主动杀进程，让 WDA 挂在那儿
+                return True
+
+            rc = proc.poll()
+            if rc is not None:
+                print(f"[ios] runwda 进程退出 rc={rc}，未检测到成功日志，udid={udid}")
+                return False
+
+            if time.time() - start > self.runwda_wait_timeout:
+                print(f"[ios] runwda 等待超时({self.runwda_wait_timeout}s)，未确认成功，udid={udid}")
+                try:
+                    proc.terminate()
+                except Exception:
+                    pass
+                return False
+
+            time.sleep(0.2)
+
+    def _run_wda_with_retry(self, udid: str, on_wda_ready: Optional[Callable[[str], None]]) -> bool:
+        for attempt in range(1, self.runwda_max_retry + 1):
+            print(f"[ios] runwda 尝试 {attempt}/{self.runwda_max_retry}，udid={udid}")
+            ok = self._run_wda_once_async(udid, on_wda_ready)
+            if ok:
+                print(f"[ios] runwda 第 {attempt} 次尝试成功，udid={udid}")
+                return True
+
+            print(f"[ios] runwda 第 {attempt} 次尝试失败，udid={udid}")
+            if attempt < self.runwda_max_retry:
+                time.sleep(self.runwda_retry_interval)
+
+        print(f"[ios] runwda 多次失败，放弃，udid={udid}")
+        return False
+
+    # ===== 对外主流程 =====
+    def activate_ios17(self, udid: str, on_wda_ready: Optional[Callable[[str], None]] = None) -> None:
+        print(f"[WDA] iOS17+ 激活开始，udid={udid}, 回调={on_wda_ready}")
+
+        # 1. 先确保 tunnel 在跑
+        self._spawn_tunnel()
+
+        # 2. 配对
+        try:
+            self._pair_until_success(udid)
+        except Exception as e:
+            print(f"[WDA] pair 失败，终止激活流程 udid={udid}, err={e}")
+            return
+
+        # 3. 挂镜像（非致命）
+        try:
+            self._mount_dev_image(udid)
+        except Exception as e:
+            print(f"[WDA] 挂载开发者镜像异常(忽略) udid={udid}, err={e}")
+
+        # 4. runwda + 回调
+        ok = self._run_wda_with_retry(udid, on_wda_ready)
+        if not ok:
+            print(f"[WDA] runwda 多次失败，可能需要手动检查设备，udid={udid}")
+
+        print(f"[WDA] iOS17+ 激活流程结束（不代表一定成功），udid={udid}")

Module/Main.py

@@ -0,0 +1,176 @@
+import asyncio
+import ctypes
+# ===== Main.py 顶部放置（所有 import 之前）=====
+import os
+import sys
+from pathlib import Path
+from hypercorn.asyncio import serve
+from hypercorn.config import Config
+
+from Module.DeviceInfo import DeviceInfo
+from Module.FlaskSubprocessManager import FlaskSubprocessManager
+from Utils.AiUtils import AiUtils
+from Utils.DevDiskImageDeployer import DevDiskImageDeployer
+from Utils.LogManager import LogManager
+
+# 确定 exe 或 py 文件所在目录
+BASE = Path(getattr(sys, 'frozen', False) and sys.executable or __file__).resolve().parent
+LOG_DIR = BASE / "log"
+LOG_DIR.mkdir(exist_ok=True)  # 确保 log 目录存在
+
+print(f"日志目录: {LOG_DIR}")
+
+def _run_flask_role():
+    from Module.FlaskService import get_app, bootstrap_server_side_effects
+    print("Flask Pid:", os.getpid())
+    port = int(os.getenv("FLASK_COMM_PORT", "34566"))  # 固定端口的兜底仍是 34567
+    app = get_app()
+    flaskPort = port + 1
+    AiUtils.flask_port_free(flaskPort)
+    bootstrap_server_side_effects()
+
+    # ==== 关键：统一获取 resources 目录 ====
+    if "__compiled__" in globals():
+        # 被 Nuitka 编译后的 exe 运行时
+        base_dir = os.path.dirname(sys.executable)   # exe 所在目录
+    else:
+        # 开发环境，直接跑 .py
+        cur_file = os.path.abspath(__file__)         # Module/Main.py 所在目录
+        base_dir = os.path.dirname(os.path.dirname(cur_file))  # 回到项目根 iOSAi
+
+    resource_dir = os.path.join(base_dir, "resources")
+
+    # Hypercorn 配置
+    config = Config()
+    config.bind = [f"0.0.0.0:{flaskPort}"]
+    config.certfile = os.path.join(resource_dir, "server.crt")
+    config.keyfile = os.path.join(resource_dir, "server.key")
+    config.alpn_protocols = ["h2", "http/1.1"]
+    config.workers = 6  # 你机器 4GB → 推荐 3～4 个 worker
+
+    # 直接跑 Quart（ASGI 原生，不再用 WsgiToAsgi）
+    asyncio.run(serve(app, config))
+
+if "--role=flask" in sys.argv:
+    _run_flask_role()
+    sys.exit(0)
+
+def _ensure_wintun_installed():
+    """
+    确保 wintun.dll 已经在系统目录里：
+    - 优先从当前目录的 resources 中找 wintun.dll
+    - 如果 System32 中没有，就复制过去（需要管理员权限）
+    """
+    try:
+        # ==== 关键：统一获取 resources 目录 ====
+        if "__compiled__" in globals():
+            # Nuitka 编译后的 exe
+            base_dir = os.path.dirname(sys.executable)  # exe 所在目录
+        else:
+            # 开发环境运行 .py
+            cur_file = os.path.abspath(__file__)  # Module/Main.py 所在目录
+            base_dir = os.path.dirname(os.path.dirname(cur_file))  # 回到 iOSAi 根目录
+
+        resource_dir = os.path.join(base_dir, "resources")
+        src = os.path.join(resource_dir, "wintun.dll")
+
+        # 1. 检查源文件是否存在
+        if not os.path.exists(src):
+            print(f"[wintun] 未找到资源文件: {src}")
+            return
+
+        # 2. 系统 System32 目录
+        windir = os.environ.get("WINDIR", r"C:\Windows")
+        system32 = Path(windir) / "System32"
+        dst = system32 / "wintun.dll"
+
+        # 3. System32 中已经存在则无需复制
+        if dst.exists():
+            print(f"[wintun] System32 中已存在: {dst}")
+            return
+
+        # 4. 执行复制
+        import shutil
+        print(f"[wintun] 复制 {src} -> {dst}")
+        shutil.copy2(src, dst)
+        print("[wintun] 复制完成")
+
+    except PermissionError as e:
+        print(f"[wintun] 权限不足，无法写入 System32：{e}")
+    except Exception as e:
+        print(f"[wintun] 安装 wintun.dll 时异常: {e}")
+
+# 启动锁
+def main(arg):
+    if len(arg) != 2 or arg[1] != "iosai":
+        sys.exit(0)
+
+# 判断是否为管理员身份原型
+def isAdministrator():
+    """
+    检测当前进程是否具有管理员权限。
+    - Windows 下调用 Shell32.IsUserAnAdmin()
+    - 如果不是管理员，直接退出程序
+    """
+    try:
+        is_admin = ctypes.windll.shell32.IsUserAnAdmin()
+    except Exception:
+        # 非 Windows 或无法判断的情况，一律按“非管理员”处理
+        is_admin = False
+
+    if not is_admin:
+        print("[ERROR] 需要以管理员身份运行本程序！")
+        sys.exit(0)
+
+    return True
+
+# 项目入口
+if __name__ == "__main__":
+    # 检测是否有管理员身份权限
+    isAdministrator()
+
+    # 检测程序合法性
+    main(sys.argv)
+
+    # 清空日志
+    LogManager.clearLogs()
+
+    # 添加iOS开发包到电脑上
+    deployer = DevDiskImageDeployer(verbose=True)
+    deployer.deploy_all()
+
+    # 复制wintun.dll到system32目录下
+    _ensure_wintun_installed()
+
+    # 启动 Flask 子进程
+    manager = FlaskSubprocessManager.get_instance()
+    manager.start()
+
+    # 设备监听（即使失败/很快返回，也不会导致主进程退出）
+    try:
+        info = DeviceInfo()
+        info.listen()
+    except Exception as e:
+        print("[WARN] Device listener not running:", e)
+
+    # === 保活：阻塞主线程，直到收到 Ctrl+C/关闭 ===
+    import threading, time, signal
+    stop = threading.Event()
+
+    def _handle(_sig, _frm):
+        stop.set()
+
+    # Windows 上 SIGINT/SIGTERM 都可以拦到
+    try:
+        signal.signal(signal.SIGINT, _handle)
+        signal.signal(signal.SIGTERM, _handle)
+    except Exception:
+        pass  # 某些环境可能不支持，忽略
+
+    try:
+        while not stop.is_set():
+            time.sleep(1)
+    finally:
+        # 进程退出前记得把子进程关掉
+        manager.stop()
+

Utils/ControlUtils.py

@@ -0,0 +1,356 @@
+import math
+import random
+import re
+import time
+from typing import Tuple, List
+import tidevice
+import wda
+from wda import Client
+
+from Entity.Variables import wdaFunctionPort
+from Utils.AiUtils import AiUtils
+from Utils.LogManager import LogManager
+
+
+# 页面控制工具类
+class ControlUtils(object):
+
+    # 获取设备上的app列表
+    @classmethod
+    def getDeviceAppList(self, udid):
+        device = tidevice.Device(udid)
+        # 获取已安装的应用列表
+        apps = []
+        for app in device.installation.iter_installed():
+            apps.append({
+                "name": app.get("CFBundleDisplayName", "Unknown"),
+                "bundleId": app.get("CFBundleIdentifier", "Unknown"),
+                "version": app.get("CFBundleShortVersionString", "Unknown"),
+                "path": app.get("Path", "Unknown")
+            })
+
+        # 筛选非系统级应用（过滤掉以 com.apple 开头的系统应用）
+        noSystemApps = [app for app in apps if not app["bundleId"].startswith("com.apple")]
+        return noSystemApps
+
+    # 打开Tik Tok
+    @classmethod
+    def openTikTok(cls, session: Client, udid):
+        apps = cls.getDeviceAppList(udid)
+        tk = ""
+        for app in apps:
+            if app.get("name", "") == "TikTok":
+                tk = app.get("bundleId", "")
+
+        currentApp = session.app_current()
+        if currentApp != tk:
+            session.app_start(tk)
+
+    # 关闭Tik Tok
+    @classmethod
+    def closeTikTok(cls, session: Client, udid):
+        apps = cls.getDeviceAppList(udid)
+        tk = ""
+        for app in apps:
+            if app.get("name", "") == "TikTok":
+                tk = app.get("bundleId", "")
+        session.app_stop(tk)
+
+    # 返回
+    @classmethod
+    def clickBack(cls, session: Client):
+        try:
+
+            back = session.xpath(
+                # ① 常见中文文案
+                "//*[@label='返回' or @label='返回上一屏幕']"
+                " | "
+                # ② 英文 / 内部 name / 图标 label 的按钮（仅限 Button，且可见）
+                "//XCUIElementTypeButton[@visible='true' and ("
+                "@name='Back' or @label='Back' or "  # 英文
+                "@name='返回' or @label='返回' or "  # 中文
+                "@label='返回上一屏幕' or "  # 中文另一种
+                "@name='returnButton' or"
+                "@name='nav_bar_start_back' or "  # 内部常见 name
+                "(@name='TTKProfileNavBarBaseItemComponent' and @label='IconChevronLeftOffsetLTR')"  # 你给的特例
+                ")]"
+            )
+
+            if back.exists:
+                back.click()
+                return True
+            elif session.xpath("//*[@name='nav_bar_start_back']").exists:
+                back = session.xpath("//*[@name='nav_bar_start_back']")
+                if back.exists:
+                    back.click()
+                return True
+            elif session.xpath(
+                    "//Window[1]/Other[1]/Other[1]/Other[1]/Other[1]/Other[1]/Other[1]/Other[1]/Other[1]/Other[1]/Other[1]/Other[1]/Other[1]/Other[1]").exists:
+                back = session.xpath(
+                    "//Window[1]/Other[1]/Other[1]/Other[1]/Other[1]/Other[1]/Other[1]/Other[1]/Other[1]/Other[1]/Other[1]/Other[1]/Other[1]/Other[1]")
+                if back.exists:
+                    back.click()
+                return True
+            elif session.xpath(
+                    "(//XCUIElementTypeOther[@y='20' and @height='44']//XCUIElementTypeButton[@visible='true'])[1]").exists:
+                back = session.xpath(
+                    "(//XCUIElementTypeOther[@y='20' and @height='44']//XCUIElementTypeButton[@visible='true'])[1]")
+                if back.exists:
+                    back.click()
+                return True
+            else:
+                return False
+        except Exception as e:
+            print(e)
+            return False
+
+    @classmethod
+    def isClickBackEnabled(cls, session: Client):
+        try:
+
+            back = session.xpath(
+                # ① 常见中文文案
+                "//*[@label='返回' or @label='返回上一屏幕']"
+                " | "
+                # ② 英文 / 内部 name / 图标 label 的按钮（仅限 Button，且可见）
+                "//XCUIElementTypeButton[@visible='true' and ("
+                "@name='Back' or @label='Back' or "  # 英文
+                "@name='返回' or @label='返回' or "  # 中文
+                "@label='返回上一屏幕' or "  # 中文另一种
+                "@name='returnButton' or"
+                "@name='nav_bar_start_back' or "  # 内部常见 name
+                "(@name='TTKProfileNavBarBaseItemComponent' and @label='IconChevronLeftOffsetLTR')"  # 你给的特例
+                ")]"
+            )
+
+            if back.exists:
+                return True
+            elif session.xpath("//*[@name='nav_bar_start_back']").exists:
+                back = session.xpath("//*[@name='nav_bar_start_back']")
+                if back.exists:
+                    return True
+            elif session.xpath(
+                    "//Window[1]/Other[1]/Other[1]/Other[1]/Other[1]/Other[1]/Other[1]/Other[1]/Other[1]/Other[1]/Other[1]/Other[1]/Other[1]/Other[1]").exists:
+                back = session.xpath(
+                    "//Window[1]/Other[1]/Other[1]/Other[1]/Other[1]/Other[1]/Other[1]/Other[1]/Other[1]/Other[1]/Other[1]/Other[1]/Other[1]/Other[1]")
+                if back.exists:
+                    return True
+            elif session.xpath(
+                    "(//XCUIElementTypeOther[@y='20' and @height='44']//XCUIElementTypeButton[@visible='true'])[1]").exists:
+                back = session.xpath(
+                    "(//XCUIElementTypeOther[@y='20' and @height='44']//XCUIElementTypeButton[@visible='true'])[1]")
+                if back.exists:
+                    return True
+            else:
+                return False
+        except Exception as e:
+            print(e)
+            return False
+
+    # 点赞
+    @classmethod
+    def clickLike(cls, session: Client, udid):
+        try:
+            from script.ScriptManager import ScriptManager
+
+            width, height, scale = ScriptManager.get_screen_info(udid)
+
+            if scale == 3.0:
+                x, y = AiUtils.findImageInScreen("add", udid)
+                if x > -1:
+                    LogManager.method_info(f"点赞了,点赞的坐标是：{x // scale, y // scale + 50}", "关注打招呼", udid)
+                    session.click(int(x // scale), int(y // scale + 50))
+                    return True
+                else:
+                    LogManager.method_info("没有找到目标", "关注打招呼", udid)
+                    return False
+            else:
+                x, y = AiUtils.findImageInScreen("like1", udid)
+                if x > -1:
+                    LogManager.method_info(f"点赞了,点赞的坐标是：{x // scale, y // scale}", "关注打招呼", udid)
+                    session.click(int(x // scale), int(y // scale))
+                    return True
+                else:
+                    LogManager.method_info("没有找到目标", "关注打招呼", udid)
+                    return False
+
+
+
+        except Exception as e:
+            LogManager.method_info(f"点赞出现异常,异常的原因：{e}", "关注打招呼", udid)
+            raise False
+
+    # 点击搜索
+    @classmethod
+    def clickSearch(cls, session: Client):
+        # obj = session.xpath("//*[@name='搜索']")
+        obj = session(xpath='//*[@name="搜索" or @label="搜索" or @name="Search" or @label="Search"]')
+        try:
+            if obj.exists:
+                obj.click()
+                return True
+        except Exception as e:
+            print(e)
+            return False
+
+    # 点击收件箱按钮
+    @classmethod
+    def clickMsgBox(cls, session: Client):
+        box = session.xpath("//XCUIElementTypeButton[name='a11y_vo_inbox']")
+        if box.exists:
+            box.click()
+            return True
+        else:
+            return False
+
+    # 获取主播详情页的第一个视频
+    @classmethod
+    def clickFirstVideoFromDetailPage(cls, session: Client):
+
+        videoCell = session.xpath(
+            '(//XCUIElementTypeCollectionView//XCUIElementTypeCell[.//XCUIElementTypeImage[@name="profile_video"]])[1]')
+
+        tab = session.xpath(
+            '//XCUIElementTypeButton[@name="TTKProfileTabVideoButton_0" or contains(@label,"作品") or contains(@name,"作品")]'
+        ).get(timeout=5)  # 某些版本 tab.value 可能就是数量；或者 tab.label 类似 “作品 7”
+        m = re.search(r"\d+", tab.label)
+
+        num = 0
+
+        if m:
+            # 判断当前的作品的数量
+            num = int(m.group())
+            print("作品数量为：", num)
+
+        if videoCell.exists:
+            videoCell.click()
+            # 点击视频
+            print("找到主页的第一个视频")
+            return True, num
+        else:
+            print("没有找到主页的第一个视频")
+            return False, num
+
+    @classmethod
+    def clickFollow(cls, session, aid):
+        # 1) 含“关注/已关注/Follow/Following”的首个 cell
+        cell_xpath = (
+            '(//XCUIElementTypeCollectionView[@name="TTKSearchCollectionComponent"]'
+            '//XCUIElementTypeCell[.//XCUIElementTypeButton[@name="关注" or @name="Follow" or @name="已关注" or @name="Following"]])[1]'
+        )
+        cell = session.xpath(cell_xpath).get(timeout=5)
+
+        # 2) 先试“用户信息 Button”（label/name 里包含 aid）
+        profile_btn_xpath = (
+            f'{cell_xpath}//XCUIElementTypeButton[contains(@label, "{aid}") or contains(@name, "{aid}")]'
+        )
+
+        try:
+            profile_btn = session.xpath(profile_btn_xpath).get(timeout=3)
+            profile_btn.click()
+        except wda.WDAElementNotFoundError:
+            # 3) 兜底：用“关注”按钮做锚点，向左偏移点击头像/用户名区域
+            follow_btn_xpath = (
+                f'{cell_xpath}//XCUIElementTypeButton[@name="关注" or @name="Follow" or @name="已关注" or @name="Following"]'
+            )
+            follow_btn = session.xpath(follow_btn_xpath).get(timeout=5)
+            rect = follow_btn.bounds
+            left_x = max(1, rect.x - 20)
+            center_y = rect.y + rect.height // 2
+            session.tap(left_x, center_y)
+
+    @classmethod
+    def userClickProfile(cls, session, aid):
+        try:
+            user_btn = session.xpath("(//XCUIElementTypeButton[@name='用户' and @visible='true'])[1]")
+            if user_btn.exists:
+                user_btn.click()
+                time.sleep(3)
+                follow_btn = session.xpath(
+                    "(//XCUIElementTypeTable//XCUIElementTypeButton[@name='关注' or @name='已关注'])[1]"
+                ).get(timeout=5)
+                if follow_btn:
+                    x, y, w, h = follow_btn.bounds
+                    # 垂直方向中心 + 随机 3~8 像素偏移
+                    cy = int(y + h / 2 + random.randint(-8, 8))
+                    # 横向往左偏移 80~120 像素之间的随机值
+                    cx = int(x - random.randint(80, 120))
+                    # 点击
+                    session.tap(cx, cy)
+                    return True
+
+            return False
+        except Exception as e:
+            print(e)
+            return False
+
+    @classmethod
+    def random_micro_swipe(
+            cls,
+            center_x: int,
+            center_y: int,
+            session,
+            points: int = 6,
+            duration_ms: int = 15,
+    ) -> None:
+        """
+        在 (center_x, center_y) 附近做 20px 左右的不规则微滑动。
+        使用 facebook-wda 的 session.swipe(x1, y1, x2, y2, duration) 接口。
+        """
+        # 1. 随机方向
+        angle = random.uniform(0, 2 * math.pi)
+        length = random.uniform(18, 22)  # 20px 左右
+        end_x = center_x + length * math.cos(angle)
+        end_y = center_y + length * math.sin(angle)
+
+        # 2. 限制在 20px 圆内（防止超出）
+        def clamp_to_circle(x, y, cx, cy, r):
+            dx = x - cx
+            dy = y - cy
+            if dx * dx + dy * dy > r * r:
+                scale = r / math.hypot(dx, dy)
+                x = cx + dx * scale
+                y = cy + dy * scale
+            return int(round(x)), int(round(y))
+
+        end_x, end_y = clamp_to_circle(end_x, end_y, center_x, center_y, 20)
+
+        # 3. 加入轻微噪声，制造“不规则”曲线
+        noise = 3  # 最大偏移像素
+        mid_count = points - 2
+        mid_points: List[Tuple[int, int]] = []
+        for i in range(1, mid_count + 1):
+            t = i / (mid_count + 1)
+            # 线性插值 + 垂直方向噪声
+            x = center_x * (1 - t) + end_x * t
+            y = center_y * (1 - t) + end_y * t
+            perp_angle = angle + math.pi / 2  # 垂直方向
+            offset = random.uniform(-noise, noise)
+            x += offset * math.cos(perp_angle)
+            y += offset * math.sin(perp_angle)
+            x, y = clamp_to_circle(x, y, center_x, center_y, 20)
+            mid_points.append((int(round(x)), int(round(y))))
+
+        # 4. 构造完整轨迹
+        trajectory: List[Tuple[int, int]] = (
+                [(center_x, center_y)] + mid_points + [(end_x, end_y)]
+        )
+
+        # 5. 使用 facebook-wda 的 swipe 接口（逐段 swipe）
+        #    由于总时长太短，我们一次性 swipe 到终点，但用多点轨迹模拟
+        #    facebook-wda 支持 swipe(x1, y1, x2, y2, duration)
+        #    我们直接用起点 -> 终点，duration 用总时长
+        print("开始微滑动")
+        session.swipe(center_x, center_y, end_x, end_y, duration_ms / 1000)
+        print("随机微滑动：", trajectory)
+
+    # 向上滑动 脚本内部使用
+    @classmethod
+    def swipe_up(cls, client):
+        client.swipe(200, 350, 200, 250, 0.05)
+
+    # 向下滑动，脚本内使用
+    @classmethod
+    def swipe_down(cls, udid):
+        dev = wda.USBClient(udid, wdaFunctionPort)
+        dev.swipe(200, 250, 200, 350, 0.05)

Utils/CountryEnum.py

@@ -0,0 +1,271 @@
+class CountryLanguageMapper:
+
+    # 初始化一个字典，映射国家到语言代码
+    country_to_language = {
+        "中国大陆": "zh-CN",
+        "台湾": "zh-TW",
+        "香港": "zh-TW",
+        "澳门": "zh-TW",
+        "美国": "en",
+        "英国": "en",
+        "澳大利亚": "en",
+        "日本": "ja",
+        "韩国": "ko",
+        "俄罗斯": "ru",
+        "法国": "fr",
+        "德国": "de",
+        "意大利": "it",
+        "西班牙": "es",
+        "墨西哥": "es",
+        "巴西": "pt",
+        "葡萄牙": "pt",
+        "印度": "hi",
+        "泰国": "th",
+        "越南": "vi",
+        "马来西亚": "ms",
+        "印度尼西亚": "id",
+        "阿联酋": "ar",
+        "沙特阿拉伯": "ar",
+        "埃及": "ar",
+        "以色列": "he",
+        "缅甸": "my",
+        "斯里兰卡": "ta",
+        "巴基斯坦": "ur",
+        "孟加拉国": "bn",
+        "波兰": "pl",
+        "荷兰": "nl",
+        "罗马尼亚": "ro",
+        "土耳其": "tr",
+        "老挝": "lo",
+        "乌克兰": "uk",
+        "芬兰": "fi",
+        "南非": "af",
+        "阿尔巴尼亚": "sq",
+        "安道尔": "ca",
+        "安提瓜和巴布达": "en",
+        "阿根廷": "es",
+        "亚美尼亚": "hy",
+        "奥地利": "de",
+        "阿塞拜疆": "az",
+        "巴哈马": "en",
+        "巴林": "ar",
+        "巴巴多斯": "en",
+        "白俄罗斯": "be",
+        "比利时": "fr",
+        "伯利兹": "en",
+        "贝宁": "fr",
+        "不丹": "dz",
+        "玻利维亚": "es",
+        "波斯尼亚和黑塞哥维那": "bs",
+        "博茨瓦纳": "en",
+        "文莱": "ms",
+        "保加利亚": "bg",
+        "布基纳法索": "fr",
+        "布隆迪": "fr",
+        "柬埔寨": "km",
+        "喀麦隆": "fr",
+        "加拿大": "en",
+        "佛得角": "pt",
+        "开曼群岛": "en",
+        "中非共和国": "fr",
+        "乍得": "fr",
+        "智利": "es",
+        "中国": "zh-CN",
+        "圣诞岛": "en",
+        "科科斯群岛": "en",
+        "哥伦比亚": "es",
+        "科摩罗": "ar",
+        "刚果": "fr",
+        "库克群岛": "en",
+        "哥斯达黎加": "es",
+        "科特迪瓦": "fr",
+        "克罗地亚": "hr",
+        "古巴": "es",
+        "库拉索": "nl",
+        "塞浦路斯": "el",
+        "捷克": "cs",
+        "丹麦": "da",
+        "吉布提": "fr",
+        "多米尼克": "en",
+        "多米尼加共和国": "es",
+        "厄瓜多尔": "es",
+        "萨尔瓦多": "es",
+        "赤道几内亚": "es",
+        "厄立特里亚": "ti",
+        "爱沙尼亚": "et",
+        "埃斯瓦蒂尼": "en",
+        "埃塞俄比亚": "am",
+        "福克兰群岛": "en",
+        "法罗群岛": "fo",
+        "斐济": "en",
+        "法属圭亚那": "fr",
+        "法属波利尼西亚": "fr",
+        "法属南部领地": "fr",
+        "加蓬": "fr",
+        "冈比亚": "en",
+        "格鲁吉亚": "ka",
+        "加纳": "en",
+        "直布罗陀": "en",
+        "希腊": "el",
+        "格陵兰": "kl",
+        "格林纳达": "en",
+        "瓜德罗普": "fr",
+        "关岛": "en",
+        "危地马拉": "es",
+        "根西岛": "en",
+        "几内亚": "fr",
+        "几内亚比绍": "pt",
+        "圭亚那": "en",
+        "海地": "fr",
+        "赫德岛和麦克唐纳群岛": "en",
+        "梵蒂冈": "it",
+        "洪都拉斯": "es",
+        "中国香港特别行政区": "zh-TW",
+        "匈牙利": "hu",
+        "冰岛": "is",
+        "伊朗": "fa",
+        "伊拉克": "ar",
+        "爱尔兰": "en",
+        "曼岛": "en",
+        "牙买加": "en",
+        "泽西岛": "en",
+        "约旦": "ar",
+        "哈萨克斯坦": "kk",
+        "肯尼亚": "en",
+        "基里巴斯": "en",
+        "朝鲜": "ko",
+        "科威特": "ar",
+        "吉尔吉斯斯坦": "ky",
+        "拉脱维亚": "lv",
+        "黎巴嫩": "ar",
+        "莱索托": "en",
+        "利比里亚": "en",
+        "利比亚": "ar",
+        "列支敦士登": "de",
+        "立陶宛": "lt",
+        "卢森堡": "fr",
+        "中国澳门特别行政区": "zh-TW",
+        "马达加斯加": "fr",
+        "马拉维": "en",
+        "马尔代夫": "dv",
+        "马里": "fr",
+        "马耳他": "mt",
+        "马绍尔群岛": "en",
+        "马提尼克": "fr",
+        "毛里塔尼亚": "ar",
+        "毛里求斯": "en",
+        "马约特": "fr",
+        "密克罗尼西亚": "en",
+        "摩尔多瓦": "ro",
+        "摩纳哥": "fr",
+        "蒙古": "mn",
+        "黑山": "sr",
+        "蒙特塞拉特": "en",
+        "摩洛哥": "ar",
+        "莫桑比克": "pt",
+        "纳米比亚": "en",
+        "瑙鲁": "en",
+        "尼泊尔": "ne",
+        "新喀里多尼亚": "fr",
+        "新西兰": "en",
+        "尼加拉瓜": "es",
+        "尼日尔": "fr",
+        "尼日利亚": "en",
+        "纽埃": "en",
+        "诺福克岛": "en",
+        "北马其顿": "mk",
+        "北马里亚纳群岛": "en",
+        "挪威": "no",
+        "阿曼": "ar",
+        "帕劳": "en",
+        "巴勒斯坦": "ar",
+        "巴拿马": "es",
+        "巴布亚新几内亚": "en",
+        "巴拉圭": "es",
+        "秘鲁": "es",
+        "菲律宾": "tl",
+        "皮特凯恩群岛": "en",
+        "波多黎各": "es",
+        "卡塔尔": "ar",
+        "留尼汪": "fr",
+        "卢旺达": "rw",
+        "圣巴泰勒米": "fr",
+        "圣赫勒拿": "en",
+        "圣基茨和尼维斯": "en",
+        "圣卢西亚": "en",
+        "法属圣马丁": "fr",
+        "圣皮埃尔和密克隆": "fr",
+        "圣文森特和格林纳丁斯": "en",
+        "萨摩亚": "sm",
+        "圣马力诺": "it",
+        "圣多美和普林西比": "pt",
+        "塞内加尔": "fr",
+        "塞尔维亚": "sr",
+        "塞舌尔": "fr",
+        "塞拉利昂": "en",
+        "新加坡": "en",
+        "荷属圣马丁": "nl",
+        "斯洛伐克": "sk",
+        "斯洛文尼亚": "sl",
+        "所罗门群岛": "en",
+        "索马里": "so",
+        "南乔治亚岛和南桑威奇群岛": "en",
+        "南苏丹": "en",
+        "苏丹": "ar",
+        "苏里南": "nl",
+        "斯瓦尔巴群岛和扬马延岛": "no",
+        "瑞典": "sv",
+        "瑞士": "de",
+        "叙利亚": "ar",
+        "台湾省": "zh-TW",
+        "塔吉克斯坦": "tg",
+        "坦桑尼亚": "sw",
+        "东帝汶": "tet",
+        "多哥": "fr",
+        "托克劳": "en",
+        "汤加": "to",
+        "特立尼达和多巴哥": "en",
+        "突尼斯": "ar",
+        "土库曼斯坦": "tk",
+        "特克斯和凯科斯群岛": "en",
+        "图瓦卢": "en",
+        "乌干达": "en",
+        "美国本土外小岛屿": "en",
+        "乌拉圭": "es",
+        "乌兹别克斯坦": "uz",
+        "瓦努阿图": "bi",
+        "委内瑞拉": "es",
+        "英属维尔京群岛": "en",
+        "美属维尔京群岛": "en",
+        "瓦利斯和富图纳": "fr",
+        "西撒哈拉": "ar",
+        "也门": "ar",
+        "赞比亚": "en",
+        "津巴布韦": "en",
+        "阿富汗": "fa",
+        "阿尔及利亚": "ar",
+        "美属萨摩亚": "en",
+        "安哥拉": "pt",
+        "安圭拉": "en",
+        "南极洲": "en",
+        "百慕大": "en",
+        "荷属加勒比区": "nl",
+        "布韦岛": "no",
+        "英属印度洋领地": "en",
+
+    }
+
+    @classmethod
+    def get_language_code(cls, country):
+        return cls.country_to_language.get(country)
+
+# 使用示例
+if __name__ == "__main__":
+    mapper = CountryLanguageMapper()
+    countries = ['英国', '美国', '日本', '未知国家']
+    for country in countries:
+        code = mapper.get_language_code(country)
+        if code:
+            print(f"{country} 对应的语言代码是 {code}")
+        else:
+            print(f"没有找到 {country} 对应的语言代码")

Utils/DevDiskImageDeployer.py

@@ -0,0 +1,135 @@
+# support_deployer.py
+import os
+import re
+import shutil
+from pathlib import Path
+from dataclasses import dataclass, field
+from typing import Iterable, Optional
+
+VERSION_RE = re.compile(r"^\d+(?:\.\d+)*$")  # 15 / 15.6 / 16.7 / 16.7.1
+
+def _find_support_root(hint: Optional[Path]) -> Optional[Path]:
+    """
+    1) 优先：显式传入的 hint
+    2) 其次：环境变量 SUPPORT_DDI_DIR
+    3) 再次：从 __file__ 所在目录向上搜索 3 层，找名为 'SupportFiles' 的目录
+    """
+    if hint and hint.exists():
+        return hint.resolve()
+
+    env = os.environ.get("SUPPORT_DDI_DIR")
+    if env:
+        p = Path(env).expanduser()
+        if p.exists():
+            return p.resolve()
+
+    here = Path(__file__).resolve().parent
+    for _ in range(4):  # 当前目录 + 向上 3 层
+        cand = here / "SupportFiles"
+        if cand.exists():
+            return cand.resolve()
+        here = here.parent
+    return None
+
+
+@dataclass
+class DevDiskImageDeployer:
+    """
+    同步 SupportFiles/<version>/ 或 SupportFiles/<version>.zip 到 ~/.tidevice/device-support
+    - 目录：复制为 ~/.tidevice/device-support/<version>/
+    - zip：原样复制为 ~/.tidevice/device-support/<version>.zip （不解压）
+    - 已存在则跳过；如设置 overwrite=True 则覆盖
+    """
+    project_support_root: Optional[Path] = None
+    cache_root: Optional[Path] = None
+    verbose: bool = True
+    dry_run: bool = False
+    overwrite: bool = False
+
+    _src_dir: Path = field(init=False, repr=False)
+    _cache_dir: Path = field(init=False, repr=False)
+
+    def __post_init__(self):
+        src = _find_support_root(self.project_support_root)
+        if src is None:
+            raise FileNotFoundError(
+                "未找到 SupportFiles 目录。"
+                "可传入 project_support_root，或设置环境变量 SUPPORT_DDI_DIR，"
+                "或确保在当前文件上层 3 级目录内存在名为 'SupportFiles' 的目录。"
+            )
+        self._src_dir = src
+
+        if self.cache_root is None:
+            self._cache_dir = Path.home() / ".tidevice" / "device-support"
+        else:
+            self._cache_dir = Path(self.cache_root).expanduser().resolve()
+        self._cache_dir.mkdir(parents=True, exist_ok=True)
+
+        if self.verbose:
+            print(f"[INFO] resolved SupportFiles = {self._src_dir}")
+            print(f"[INFO] cache_dir            = {self._cache_dir}")
+
+            parent = self._src_dir.parent
+            try:
+                siblings = ", ".join(sorted(p.name for p in parent.iterdir() if p.is_dir()))
+                print(f"[INFO] SupportFiles parent = {parent}")
+                print(f"[INFO] siblings            = {siblings}")
+            except Exception:
+                pass
+
+    def deploy_all(self):
+        entries = list(self._iter_version_entries(self._src_dir))
+        copied = skipped = 0
+
+        for p, kind, version in entries:
+            # kind: "dir" 或 "zip"
+            if kind == "dir":
+                dst = self._cache_dir / version
+                exists = dst.exists()
+                if exists and not self.overwrite:
+                    skipped += 1
+                    # if self.verbose:
+                    #     print(f"[SKIP] {dst} 已存在（目录）")
+                    continue
+                if exists and self.overwrite and not self.dry_run:
+                    shutil.rmtree(dst)
+
+                if self.verbose:
+                    print(f"[COPY] DIR  {p} -> {dst}")
+                if not self.dry_run:
+                    shutil.copytree(p, dst)
+                copied += 1
+
+            elif kind == "zip":
+                dst = self._cache_dir / f"{version}.zip"
+                exists = dst.exists()
+                if exists and not self.overwrite:
+                    skipped += 1
+                    # if self.verbose:
+                    #     print(f"[SKIP] {dst} 已存在（zip）")
+                    continue
+                if exists and self.overwrite and not self.dry_run:
+                    dst.unlink()
+
+                if self.verbose:
+                    print(f"[COPY] ZIP  {p} -> {dst}")
+                if not self.dry_run:
+                    # 用 copy2 保留 mtime 等元数据
+                    shutil.copy2(p, dst)
+                copied += 1
+
+        if self.verbose:
+            print(f"[SUMMARY] copied={copied}, skipped={skipped}, total={copied+skipped}")
+
+    # -------- helpers --------
+    def _iter_version_entries(self, root: Path) -> Iterable[tuple[Path, str, str]]:
+        """
+        迭代返回 (路径, 类型, 版本号)
+        - 目录：名称需匹配版本号
+        - zip：stem（去除后缀）的名称需匹配版本号
+        """
+        for p in sorted(root.iterdir()):
+            if p.is_dir() and VERSION_RE.match(p.name):
+                yield (p, "dir", p.name)
+            elif p.is_file() and p.suffix.lower() == ".zip" and VERSION_RE.match(p.stem):
+                yield (p, "zip", p.stem)

Utils/IOSAIStorage.py

@@ -0,0 +1,88 @@
+import json
+import os
+from pathlib import Path
+
+
+class IOSAIStorage:
+
+    @staticmethod
+    def _get_iosai_dir() -> Path:
+        """获取 C:/Users/<用户名>/IOSAI/ 目录"""
+        user_dir = Path.home()
+        iosai_dir = user_dir / "IOSAI"
+        iosai_dir.mkdir(parents=True, exist_ok=True)
+        return iosai_dir
+
+
+    @classmethod
+    def save(cls, data: dict | list, filename: str = "data.json", mode: str = "overwrite") -> Path:
+        file_path = cls._get_iosai_dir() / filename
+        file_path.parent.mkdir(parents=True, exist_ok=True)
+
+        def _load_json():
+            try:
+                return json.loads(file_path.read_text("utf-8"))
+            except Exception:
+                return {} if isinstance(data, dict) else []
+
+        if mode == "merge" and isinstance(data, dict):
+            old = _load_json()
+            if not isinstance(old, dict):
+                old = {}
+            old.update(data)
+            to_write = old
+        elif mode == "append" and isinstance(data, list):
+            old = _load_json()
+            if not isinstance(old, list):
+                old = []
+            old.extend(data)
+            to_write = old
+        else:
+            to_write = data  # 覆盖
+
+        # 原子写入
+        tmp = file_path.with_suffix(file_path.suffix + ".tmp")
+        with open(tmp, "w", encoding="utf-8") as f:
+            json.dump(to_write, f, ensure_ascii=False, indent=2)
+        os.replace(tmp, file_path)
+        print(f"[IOSAIStorage] 已写入: {file_path}")
+        return file_path
+
+    @classmethod
+    def load(cls, filename: str = "data.json") -> dict | list | None:
+        """
+        从 C:/Users/<用户名>/IOSAI/filename 读取数据
+        """
+        file_path = cls._get_iosai_dir() / filename
+        if not file_path.exists():
+            print(f"[IOSAIStorage] 文件不存在: {file_path}")
+            return {}
+
+        try:
+            with open(file_path, "r", encoding="utf-8") as f:
+                return json.load(f)
+        except Exception as e:
+            print(f"[IOSAIStorage] 读取失败: {e}")
+            return {}
+
+
+    @classmethod
+    def overwrite(cls, data: dict | list, filename: str = "data.json") -> Path:
+        """
+        强制覆盖写入数据到 C:/Users/<用户名>/IOSAI/filename
+        （无论是否存在，都会写入）
+        """
+        file_path = cls._get_iosai_dir() / filename
+        try:
+            # "w" 模式本身就是覆盖，但这里单独做一个方法
+            with open(file_path, "w", encoding="utf-8") as f:
+                json.dump(data, f, ensure_ascii=False, indent=2)
+            print(f"[IOSAIStorage] 已覆盖写入: {file_path}")
+        except Exception as e:
+            print(f"[IOSAIStorage] 覆盖失败: {e}")
+        return file_path
+
+
+
+
+

Utils/JsonUtils.py

@@ -0,0 +1,262 @@
+import json
+import os
+from pathlib import Path
+
+import portalocker as locker  # ① 引入跨平台锁
+
+
+class JsonUtils:
+    @staticmethod
+    def _normalize_filename(filename: str) -> str:
+        """
+        确保文件名以 .json 结尾
+        """
+        if not filename.endswith(".json"):
+            filename = f"{filename}.json"
+        return filename
+
+    @staticmethod
+    def _get_data_path(filename: str) -> str:
+        """
+        根据文件名生成 data 目录下的完整路径
+        """
+        filename = JsonUtils._normalize_filename(filename)
+        base_dir = os.path.abspath(os.path.dirname(os.path.dirname(__file__)))  # 当前项目根目录
+        data_dir = os.path.join(base_dir, "data")
+        Path(data_dir).mkdir(parents=True, exist_ok=True)  # 确保 data 目录存在
+        return os.path.join(data_dir, filename)
+
+    @staticmethod
+    def read_json(filename: str) -> dict:
+        """
+        读取 JSON 文件，返回字典
+        如果文件不存在，返回空字典
+        """
+        file_path = JsonUtils._get_data_path(filename)
+        try:
+            if not os.path.exists(file_path):
+                return {}
+            with open(file_path, "r", encoding="utf-8") as f:
+                data = json.load(f)
+                return data if isinstance(data, dict) else {}
+        except Exception as e:
+            print(f"读取 JSON 文件失败: {e}")
+            return {}
+
+    @staticmethod
+    def write_json(filename: str, data: dict, overwrite: bool = True) -> bool:
+        """
+        将字典写入 JSON 文件
+        :param filename: 文件名（不用写后缀，自动补 .json）
+        :param data: 要写入的字典
+        :param overwrite: True=覆盖写，False=合并更新
+        """
+        file_path = JsonUtils._get_data_path(filename)
+        try:
+            if not overwrite and os.path.exists(file_path):
+                with open(file_path, "r", encoding="utf-8") as f:
+                    old_data = json.load(f)
+                    if not isinstance(old_data, dict):
+                        old_data = {}
+                old_data.update(data)
+                data = old_data
+
+            with open(file_path, "w", encoding="utf-8") as f:
+                json.dump(data, f, ensure_ascii=False, indent=4)
+            return True
+        except Exception as e:
+            print(f"写入 JSON 文件失败: {e}")
+            return False
+
+    @staticmethod
+    def update_json(filename: str, new_data: dict) -> bool:
+        """
+        修改 JSON 文件：
+        - 如果 key 已存在，则修改其值
+        - 如果 key 不存在，则新增
+        """
+        try:
+            data = JsonUtils.read_json(filename)
+            if not isinstance(data, dict):
+                data = {}
+            data.update(new_data)
+            return JsonUtils.write_json(filename, data)
+        except Exception as e:
+            print(f"更新 JSON 文件失败: {e}")
+            return False
+
+    @staticmethod
+    def delete_json_key(filename: str, key: str) -> bool:
+        """
+        删除 JSON 文件中的某个 key
+        """
+        try:
+            data = JsonUtils.read_json(filename)
+            if not isinstance(data, dict):
+                data = {}
+            if key in data:
+                del data[key]
+            return JsonUtils.write_json(filename, data)
+        except Exception as e:
+            print(f"删除 JSON key 失败: {e}")
+            return False
+    # "-------------------------------------------------"
+    @classmethod
+    def _read_json_list(cls, file_path: Path) -> list:
+        try:
+            if not file_path.exists():
+                return []
+            with file_path.open("r", encoding="utf-8") as f:
+                data = json.load(f)
+            return data if isinstance(data, list) else []
+        except Exception:
+            return []
+
+    @classmethod
+    def _write_json_list(cls, file_path: Path, data: list) -> None:
+        file_path.parent.mkdir(parents=True, exist_ok=True)
+        with file_path.open("w", encoding="utf-8") as f:
+            json.dump(data, f, ensure_ascii=False, indent=4)
+
+    # --- 新增：通用追加（不做字段校验） ---
+    # @classmethod
+    # def append_json_items(cls, items, filename="log/last_message.json"):
+    #     """
+    #     将 dict 或 [dict, ...] 追加到 JSON 文件（数组）中；不校验字段。
+    #     """
+    #     file_path = Path(filename)
+    #     data = cls._read_json_list(file_path)
+    #
+    #     # 统一成 list
+    #     if isinstance(items, dict):
+    #         items = [items]
+    #     elif not isinstance(items, list):
+    #         # 既不是 dict 也不是 list，直接忽略
+    #         return
+    #
+    #     # 只接受字典项
+    #     items = [it for it in items if isinstance(it, dict)]
+    #     if not items:
+    #         return
+    #
+    #     data.extend(items)
+    #
+    #     # LogManager.method_info(filename,"路径")
+    #     cls._write_json_list(file_path, data)
+
+    @classmethod
+    def append_json_items(cls, items, filename="log/last_message.json"):
+        file_path = Path(filename)
+        data = cls._read_json_list(file_path)
+
+        # 统一成 list
+        if isinstance(items, dict):
+            items = [items]
+        elif not isinstance(items, list):
+            return
+
+        # 只保留 sender 非空的字典
+        items = [
+            it for it in items
+            if isinstance(it, dict) and it.get("sender") != ""
+        ]
+        if not items:
+            return
+
+        data.extend(items)
+        cls._write_json_list(file_path, data)
+
+    @classmethod
+    def update_json_items(cls, match: dict, patch: dict, filename="log/last_message.json", multi: bool = True) -> int:
+        """
+        修改 JSON 文件（数组）中符合条件的项
+        :param match: 匹配条件（如 {"sender": "xxx"}）
+        :param patch: 要修改/更新的字段（如 {"status": 1}）
+        :param filename: JSON 文件路径
+        :param multi: True=修改所有匹配项，False=只修改第一项
+        :return: 修改的条数
+        """
+        file_path = Path(filename)
+        data = cls._read_json_list(file_path)
+
+        if not isinstance(match, dict) or not isinstance(patch, dict):
+            return 0
+
+        updated = 0
+        for idx, item in enumerate(data):
+            if not isinstance(item, dict):
+                continue
+
+            # 判断是否匹配
+            if all(item.get(k) == v for k, v in match.items()):
+                data[idx].update(patch)
+                updated += 1
+                if not multi:
+                    break
+
+        if updated > 0:
+            cls._write_json_list(file_path, data)
+
+        return updated
+
+
+
+
+    @classmethod
+    def query_all_json_items(cls, filename="log/last_message.json"):
+        """
+        读取 JSON 数组文件，过滤掉 sender 或 text 为空的记录
+        :param filename: 文件路径
+        :return: 有效记录列表，可能为空
+        """
+        file_path = Path(filename)
+        data = cls._read_json_list(file_path)
+        if not isinstance(data, list):
+            return []
+
+        def _is_valid(d):
+            if not isinstance(d, dict):
+                return False
+            sender = d.get("sender") or ""
+            text = d.get("text") or ""
+            return (
+                isinstance(sender, str)
+                and isinstance(text, str)
+                and sender.strip() != ""
+                and text.strip() != ""
+            )
+
+        return [item for item in data if _is_valid(item)]
+
+
+
+    @classmethod
+    def delete_json_items(cls,
+                          match: dict,
+                          filename: str = "log/last_message.json",
+                          multi: bool = True) -> int:
+        file_path = Path(filename)
+        with file_path.open('r+', encoding='utf-8') as f:
+            locker.lock(f, locker.LOCK_EX)  # ② 加独占锁（Windows/Linux 通用）
+            try:
+                data = json.load(f)
+                if not isinstance(match, dict):
+                    return 0
+
+                deleted = 0
+                new_data = []
+                for item in data:
+                    if isinstance(item, dict) and all(item.get(k) == v for k, v in match.items()):
+                        if multi or deleted == 0:  # 删多条 / 第一条
+                            deleted += 1
+                            continue
+                    new_data.append(item)
+
+                if deleted:
+                    f.seek(0)
+                    json.dump(new_data, f, ensure_ascii=False, indent=2)
+                    f.truncate()
+
+                return deleted
+            finally:
+                locker.unlock(f)  # ③ 解锁

Utils/LogManager.py

@@ -0,0 +1,277 @@
+# -*- coding: utf-8 -*-
+import datetime
+import io
+import logging
+import os
+import re
+import sys
+import shutil
+import zipfile
+from pathlib import Path
+import requests
+
+# ========= 全局：强制 UTF-8（打包 EXE / 无控制台也生效） =========
+def _force_utf8_everywhere():
+    os.environ.setdefault("PYTHONUTF8", "1")
+    os.environ.setdefault("PYTHONIOENCODING", "utf-8")
+    # windowed 模式下 stdout/stderr 可能没有 buffer，这里做保护包装
+    try:
+        if getattr(sys.stdout, "buffer", None):
+            sys.stdout = io.TextIOWrapper(sys.stdout.buffer, encoding="utf-8", errors="replace")
+    except Exception:
+        pass
+    try:
+        if getattr(sys.stderr, "buffer", None):
+            sys.stderr = io.TextIOWrapper(sys.stderr.buffer, encoding="utf-8", errors="replace")
+    except Exception:
+        pass
+
+_force_utf8_everywhere()
+
+class LogManager:
+    """
+    设备级与“设备+方法”级日志管理：
+    - log/<udid>/info.log | warning.log | error.log
+    - log/<udid>/<method>.log
+    - 文件统一 UTF-8 编码，避免 GBK/CP936 导致的 emoji 报错
+    - 提供 clearLogs() 与 upload_all_logs()
+    """
+    # 运行根目录：打包后取 exe 目录；源码运行取项目目录
+    if getattr(sys, "frozen", False):
+        projectRoot = os.path.dirname(sys.executable)
+    else:
+        projectRoot = os.path.dirname(os.path.dirname(__file__))
+
+    logDir = os.path.join(projectRoot, "log")
+    _method_loggers = {}  # 缓存“设备+方法”的 logger
+
+    # ---------- 工具：安全文本/文件名 ----------
+
+    @staticmethod
+    def _safe_text(obj) -> str:
+        """把任意对象安全转为可写字符串（避免因编码问题再次抛异常）"""
+        try:
+            if isinstance(obj, bytes):
+                return obj.decode("utf-8", "replace")
+            s = str(obj)
+            # 确保解码上屏不再出错
+            _ = s.encode("utf-8", "replace")
+            return s
+        except Exception:
+            try:
+                return repr(obj)
+            except Exception:
+                return "<unprintable>"
+
+    @classmethod
+    def _safe_filename(cls, name: str, max_len: int = 80) -> str:
+        """
+        将方法名/udid等转成安全文件名：
+        - 允许字母数字、点、下划线、连字符
+        - 保留常见 CJK 字符（中日韩）
+        - 其余替换为下划线；合并下划线；避免保留名；限长
+        """
+        if not name:
+            return "unknown"
+        name = str(name).strip()
+        name = re.sub(r'[\\/:*?"<>|\r\n\t]+', '_', name)  # Windows 非法字符
+        name = re.sub(
+            r'[^a-zA-Z0-9_.\-'
+            r'\u4e00-\u9fff'   # 中
+            r'\u3040-\u30ff'   # 日
+            r'\uac00-\ud7a3'   # 韩
+            r']+', '_', name
+        )
+        name = re.sub(r'_+', '_', name).strip(' _.')
+        name = name or "unknown"
+        if re.fullmatch(r'(?i)(CON|PRN|AUX|NUL|COM[1-9]|LPT[1-9])', name):
+            name = f"_{name}"
+        return name[:max_len] or "unknown"
+
+    # ---------- 设备级固定文件：info/warning/error ----------
+
+    @classmethod
+    def _setupLogger(cls, udid, name, logName, level=logging.INFO):
+        """创建或获取 logger，并绑定到设备目录下的固定文件（info.log / warning.log / error.log）"""
+        udid_key = cls._safe_filename(udid or "system")
+        deviceLogDir = os.path.join(cls.logDir, udid_key)
+        os.makedirs(deviceLogDir, exist_ok=True)
+        logFile = os.path.join(deviceLogDir, logName)
+
+        logger_name = f"{udid_key}_{name}"
+        logger = logging.getLogger(logger_name)
+        logger.setLevel(level)
+        logger.propagate = False  # 不向根 logger 传播，避免重复
+
+        # 避免重复添加同一路径的 file handler
+        abs_target = os.path.abspath(logFile)
+        for h in logger.handlers:
+            if isinstance(h, logging.FileHandler) and getattr(h, "baseFilename", "") == abs_target:
+                return logger
+
+        fileHandler = logging.FileHandler(logFile, mode="a", encoding="utf-8")
+        formatter = logging.Formatter(
+            "%(asctime)s - %(name)s - %(levelname)s - %(message)s",
+            datefmt="%Y-%m-%d %H:%M:%S"
+        )
+        fileHandler.setFormatter(formatter)
+        logger.addHandler(fileHandler)
+        return logger
+
+    @classmethod
+    def info(cls, text, udid="system"):
+        msg = cls._safe_text(f"[{udid}] {text}")
+        cls._setupLogger(udid, "infoLogger", "info.log", level=logging.INFO).info(msg)
+
+    @classmethod
+    def warning(cls, text, udid="system"):
+        msg = cls._safe_text(f"[{udid}] {text}")
+        cls._setupLogger(udid, "warningLogger", "warning.log", level=logging.WARNING).warning(msg)
+
+    @classmethod
+    def error(cls, text, udid="system"):
+        msg = cls._safe_text(f"[{udid}] {text}")
+        cls._setupLogger(udid, "errorLogger", "error.log", level=logging.ERROR).error(msg)
+
+    # ---------- “设备+方法”独立文件：<udid>/<method>.log ----------
+
+    @classmethod
+    def _setupMethodLogger(cls, udid: str, method: str, level=logging.INFO):
+        """
+        为某设备的某个方法单独创建 logger：log/<udid>/<method>.log
+        """
+        udid_key = cls._safe_filename(udid or "system")
+        method_key = cls._safe_filename(method or "general")
+        cache_key = (udid_key, method_key)
+
+        # 命中缓存
+        logger = cls._method_loggers.get(cache_key)
+        if logger:
+            return logger
+
+        deviceLogDir = os.path.join(cls.logDir, udid_key)
+        os.makedirs(deviceLogDir, exist_ok=True)
+        logFile = os.path.join(deviceLogDir, f"{method_key}.log")
+
+        logger_name = f"{udid_key}.{method_key}"
+        logger = logging.getLogger(logger_name)
+        logger.setLevel(level)
+        logger.propagate = False
+
+        abs_target = os.path.abspath(logFile)
+        for h in logger.handlers:
+            if isinstance(h, logging.FileHandler) and getattr(h, "baseFilename", "") == abs_target:
+                cls._method_loggers[cache_key] = logger
+                return logger
+
+        fileHandler = logging.FileHandler(logFile, mode="a", encoding="utf-8")
+        formatter = logging.Formatter(
+            "%(asctime)s - %(levelname)s - %(name)s - %(message)s",
+            datefmt="%Y-%m-%d %H:%M:%S"
+        )
+        fileHandler.setFormatter(formatter)
+        logger.addHandler(fileHandler)
+
+        cls._method_loggers[cache_key] = logger
+        return logger
+
+    @classmethod
+    def method_info(cls, text, method, udid="system"):
+        msg = cls._safe_text(f"[{udid}][{method}] {text}")
+        cls._setupMethodLogger(udid, method, level=logging.INFO).info(msg)
+
+    @classmethod
+    def method_warning(cls, text, method, udid="system"):
+        msg = cls._safe_text(f"[{udid}][{method}] {text}")
+        cls._setupMethodLogger(udid, method, level=logging.WARNING).warning(msg)
+
+    @classmethod
+    def method_error(cls, text, method, udid="system"):
+        msg = cls._safe_text(f"[{udid}][{method}] {text}")
+        cls._setupMethodLogger(udid, method, level=logging.ERROR).error(msg)
+
+    # ---------- 清空日志 ----------
+
+    @classmethod
+    def clearLogs(cls):
+        print("清空日志")
+        """启动时清空 log 目录下所有文件"""
+        # 先关闭所有 logger 的文件句柄
+        for _, logger in logging.Logger.manager.loggerDict.items():
+            if isinstance(logger, logging.Logger):
+                for handler in list(logger.handlers):
+                    try:
+                        handler.close()
+                    except Exception:
+                        pass
+                    logger.removeHandler(handler)
+
+        log_path = Path(cls.logDir)
+        if log_path.exists():
+            for item in log_path.iterdir():
+                try:
+                    if item.is_file():
+                        item.unlink(missing_ok=True)  # py>=3.8
+                    elif item.is_dir():
+                        shutil.rmtree(item, ignore_errors=True)
+                except Exception:
+                    # 不阻塞清理
+                    pass
+
+        cls._method_loggers.clear()
+
+    # ---------- 上传所有日志（内存打包 zip） ----------
+
+    @classmethod
+    def upload_all_logs(cls, server_url, token, userId, tenantId):
+        """
+        将 log/ 目录下所有日志打包为 zip（内存），上传至服务器：
+        - headers: {"vvtoken": <token>}
+        - form: {"tenantId": <tenantId>, "userId": <userId>, "file": <zip>}
+        返回 True/False
+        """
+        try:
+            log_path = Path(cls.logDir)
+            if not log_path.exists():
+                logging.info("[upload_all_logs] 日志目录不存在：%s", log_path)
+                return False
+
+            # 文件名仅用于表单，不落盘，可包含安全字符
+            timestamp = datetime.datetime.now().strftime("%Y%m%d_%H%M%S")
+            filename = f"{timestamp}_logs.zip"
+            logging.info("[upload_all_logs] 打包文件名：%s", filename)
+
+            # 1) 内存中打包 zip
+            zip_buf = io.BytesIO()
+            with zipfile.ZipFile(zip_buf, "w", compression=zipfile.ZIP_DEFLATED) as zf:
+                for p in log_path.rglob("*"):
+                    if p.is_file():
+                        arcname = str(p.relative_to(log_path))
+                        zf.write(p, arcname=arcname)
+            zip_bytes = zip_buf.getvalue()
+
+            # 2) 组织请求
+            headers = {"vvtoken": token} if token else {}
+            data = {"tenantId": tenantId, "userId": userId}
+            files = {"file": (filename, io.BytesIO(zip_bytes), "application/zip")}
+
+            # 3) 上传
+            resp = requests.post(server_url, headers=headers, data=data, files=files, timeout=120)
+            ok = False
+            try:
+                js = resp.json()
+                ok = bool(js.get("data"))
+            except Exception:
+                # 响应不是 JSON，也许是纯文本；降级按状态码判断
+                ok = resp.ok
+
+            if ok:
+                logging.info("[upload_all_logs] 上传成功：%s", server_url)
+                return True
+            else:
+                logging.error("[upload_all_logs] 上传失败，status=%s, text=%s", resp.status_code, LogManager._safe_text(resp.text))
+                return False
+
+        except Exception as e:
+            logging.error("[upload_all_logs] 异常：%s", LogManager._safe_text(e))
+            return False

Utils/OCRUtils.py

@@ -0,0 +1,243 @@
+import os
+import cv2
+import numpy as np
+from typing import List, Tuple, Union, Optional
+from PIL import Image
+
+ArrayLikeImage = Union[np.ndarray, str, Image.Image]
+
+class OCRUtils:
+    @classmethod
+    def _to_gray(cls, img: ArrayLikeImage) -> np.ndarray:
+        """
+        接受路径/np.ndarray/PIL.Image，统一转为灰度 np.ndarray。
+        """
+        # 路径
+        if isinstance(img, str):
+            arr = cv2.imread(img, cv2.IMREAD_GRAYSCALE)
+            if arr is None:
+                raise FileNotFoundError(f"图像加载失败，请检查路径: {img}")
+            return arr
+
+        # PIL.Image
+        if isinstance(img, Image.Image):
+            return cv2.cvtColor(np.array(img.convert("RGB")), cv2.COLOR_RGB2GRAY)
+
+        # numpy 数组
+        if isinstance(img, np.ndarray):
+            if img.ndim == 2:
+                return img  # 已是灰度
+            if img.ndim == 3:
+                return cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
+            raise ValueError("不支持的图像维度（期望 2D 灰度或 3D BGR/RGB）")
+
+        raise TypeError("large_image 类型必须是 str / np.ndarray / PIL.Image.Image")
+
+    @classmethod
+    def non_max_suppression(
+        cls,
+        boxes: List[List[float]],
+        scores: Optional[np.ndarray] = None,
+        overlapThresh: float = 0.5
+    ) -> np.ndarray:
+        """
+        boxes: [ [x1,y1,x2,y2], ... ]
+        scores: 每个框的置信度（用于“按分数做 NMS”）。若为 None，则退化为按 y2 排序的经典近似。
+        返回: 经过 NMS 保留的 boxes(int) ndarray，形状 (N,4)
+        """
+        if len(boxes) == 0:
+            return np.empty((0, 4), dtype=int)
+
+        boxes = np.asarray(boxes, dtype=np.float32)
+        x1, y1, x2, y2 = boxes.T
+        areas = (x2 - x1 + 1) * (y2 - y1 + 1)
+
+        if scores is None:
+            order = np.argsort(y2)  # 经典写法
+        else:
+            scores = np.asarray(scores, dtype=np.float32)
+            order = np.argsort(scores)[::-1]  # 分数从高到低
+
+        keep = []
+        while order.size > 0:
+            i = order[0] if scores is not None else order[-1]
+            keep.append(i)
+
+            rest = order[1:] if scores is not None else order[:-1]
+
+            xx1 = np.maximum(x1[i], x1[rest])
+            yy1 = np.maximum(y1[i], y1[rest])
+            xx2 = np.minimum(x2[i], x2[rest])
+            yy2 = np.minimum(y2[i], y2[rest])
+
+            w = np.maximum(0, xx2 - xx1 + 1)
+            h = np.maximum(0, yy2 - yy1 + 1)
+            inter = w * h
+            ovr = inter / areas[rest]
+
+            inds = np.where(ovr <= overlapThresh)[0]
+            order = rest[inds]
+
+        return boxes[keep].astype(int)
+
+    # @classmethod
+    # def find_template(
+    #     cls,
+    #     template_path: str,
+    #     large_image: ArrayLikeImage,
+    #     threshold: float = 0.8,
+    #     overlapThresh: float = 0.5,
+    #     return_boxes: bool = False
+    # ) -> Union[List[Tuple[int, int]], Tuple[List[Tuple[int, int]], np.ndarray]]:
+    #     """
+    #     在 large_image 中查找 template_path 模板的位置。
+    #     - large_image 可为文件路径、np.ndarray 或 PIL.Image
+    #     - threshold: 模板匹配阈值（TM_CCOEFF_NORMED）
+    #     - overlapThresh: NMS 重叠阈值
+    #     - return_boxes: True 时同时返回保留的框数组 (N,4)
+    #
+    #     返回:
+    #       centers 或 (centers, boxes)
+    #       centers: [(cx, cy), ...]
+    #       boxes:   [[x1,y1,x2,y2], ...] (np.ndarray, int)
+    #     """
+    #     # 模板（灰度）
+    #     template = cv2.imread(template_path, cv2.IMREAD_GRAYSCALE)
+    #     if template is None:
+    #         raise FileNotFoundError(f"模板图像加载失败，请检查路径: {template_path}")
+    #
+    #     # 大图（灰度）
+    #     gray = cls._to_gray(large_image)
+    #
+    #     # 模板尺寸
+    #     tw, th = template.shape[::-1]
+    #
+    #     # 模板匹配（相关系数归一化）
+    #     result = cv2.matchTemplate(gray, template, cv2.TM_CCOEFF_NORMED)
+    #
+    #     # 阈值筛选
+    #     ys, xs = np.where(result >= threshold)
+    #     if len(xs) == 0:
+    #         return ([], np.empty((0, 4), dtype=int)) if return_boxes else []
+    #
+    #     # 收集候选框与分数
+    #     boxes = []
+    #     scores = []
+    #     for (x, y) in zip(xs, ys):
+    #         boxes.append([x, y, x + tw, y + th])
+    #         scores.append(result[y, x])
+    #
+    #     # 按分数做 NMS
+    #     boxes_nms = cls.non_max_suppression(boxes, scores=np.array(scores), overlapThresh=overlapThresh)
+    #
+    #     # 计算中心点
+    #     centers = [((x1 + x2) // 2, (y1 + y2) // 2) for (x1, y1, x2, y2) in boxes_nms]
+    #
+    #
+    #
+    #     if return_boxes:
+    #         return centers, boxes_nms
+    #
+    #
+    #     return centers
+
+    @classmethod
+    def find_template(
+            cls,
+            template_path: str,
+            large_image: ArrayLikeImage,
+            threshold: float = 0.8,
+            overlapThresh: float = 0.5,
+            return_boxes: bool = False
+    ) -> Union[List[Tuple[int, int]], Tuple[List[Tuple[int, int]], np.ndarray]]:
+        """
+        在 large_image 中查找 template_path 模板的位置。
+        - large_image 可为文件路径、np.ndarray 或 PIL.Image
+        - threshold: 模板匹配阈值（TM_CCOEFF_NORMED）
+        - overlapThresh: NMS 重叠阈值
+        - return_boxes: True 时同时返回保留的框数组 (N,4)
+
+        若检测结果为空，则在相同阈值下最多重试三次（共 3 次尝试）。
+        返回:
+          centers 或 (centers, boxes)
+          centers: [(cx, cy), ...]
+          boxes:   [[x1,y1,x2,y2], ...] (np.ndarray, int)
+        """
+
+        if not os.path.isfile(template_path):
+            print(f"模板文件不存在 → {template_path}")
+            raise FileNotFoundError(f"模板文件不存在 → {template_path}")
+
+        size = os.path.getsize(template_path)
+        if size == 0:
+            print(f"模板文件大小为 0 → {template_path} ")
+            raise ValueError(f"模板文件大小为 0 → {template_path}")
+        # 模板（灰度）
+        template = cv2.imread(template_path, cv2.IMREAD_GRAYSCALE)
+        if template is None:
+            raise FileNotFoundError(f"模板图像加载失败，请检查路径: {template_path}")
+
+        # 大图（灰度）
+        gray = cls._to_gray(large_image)
+
+        # 模板尺寸
+        tw, th = template.shape[::-1]
+
+        # 内部：执行一次匹配并返回 (centers, boxes_nms)
+        def _match_once(cur_threshold: float):
+            # 模板匹配（相关系数归一化）
+            result = cv2.matchTemplate(gray, template, cv2.TM_CCOEFF_NORMED)
+
+            # 阈值筛选
+            ys, xs = np.where(result >= cur_threshold)
+            if len(xs) == 0:
+                return [], np.empty((0, 4), dtype=int)
+
+            # 收集候选框与分数
+            boxes = []
+            scores = []
+            for (x, y) in zip(xs, ys):
+                boxes.append([int(x), int(y), int(x + tw), int(y + th)])
+                scores.append(float(result[y, x]))
+
+            # 按分数做 NMS
+            boxes_nms = cls.non_max_suppression(
+                boxes,
+                scores=np.asarray(scores, dtype=np.float32),
+                overlapThresh=overlapThresh
+            )
+
+            # 计算中心点（转为 Python int）
+            centers = [(int((x1 + x2) // 2), int((y1 + y2) // 2))
+                       for (x1, y1, x2, y2) in boxes_nms]
+
+            # 统一为 np.ndarray[int]
+            boxes_nms = np.asarray(boxes_nms, dtype=int)
+            return centers, boxes_nms
+
+        # ===== 重试控制（最多 3 次）=====
+        MAX_RETRIES = 3
+        THRESHOLD_DECAY = 0.0  # 如需越试越宽松，可改为 0.02~0.05；不需要则保持 0
+        MIN_THRESHOLD = 0.6
+
+        cur_threshold = float(threshold)
+        last_centers, last_boxes = [], np.empty((0, 4), dtype=int)
+
+        for attempt in range(MAX_RETRIES):
+            centers, boxes_nms = _match_once(cur_threshold)
+            if centers:
+                if return_boxes:
+                    return centers, boxes_nms
+                return centers
+
+            # 记录最后一次（若最终失败按规范返回空）
+            last_centers, last_boxes = centers, boxes_nms
+
+            # 为下一次尝试准备（这里默认不衰减阈值；如需可打开 THRESHOLD_DECAY）
+            if attempt < MAX_RETRIES - 1 and THRESHOLD_DECAY > 0.0:
+                cur_threshold = max(MIN_THRESHOLD, cur_threshold - THRESHOLD_DECAY)
+
+        # 全部尝试失败
+        if return_boxes:
+            return last_centers, last_boxes
+        return last_centers

Utils/Requester.py

@@ -0,0 +1,147 @@
+import requests
+from Entity.Variables import prologueList, API_KEY
+from Utils.IOSAIStorage import IOSAIStorage
+from Utils.LogManager import LogManager
+
+BaseUrl = "https://crawlclient.api.yolozs.com/api/common/"
+
+
+class Requester():
+    comment = "comment"
+    prologue = "prologue"
+
+    @classmethod
+    def requestPrologue(cls, token):
+        try:
+            headers = {
+                "vvtoken": token,
+            }
+            url = BaseUrl + cls.prologue
+            result = requests.get(headers=headers, url=url, verify=False)
+            json = result.json()
+            data = json.get("data")
+            for i in data:
+                prologueList.append(i)
+        except Exception as e:
+            LogManager.method_error(f"获取requestPrologue失败,报错的原因:{e}", "获取requestPrologue异常")
+
+    # 翻译
+    @classmethod
+    def translation(cls, msg, country="英国"):
+        try:
+            if country == "":
+                country = "英国"
+
+            param = {
+                "msg": msg,
+                "country": country,
+            }
+            url = "https://ai.yolozs.com/translation"
+            result = requests.post(url=url, json=param, verify=False)
+
+            LogManager.info(f"翻译 请求的参数:{param}", "翻译")
+            LogManager.info(f"翻译,状态码:{result.status_code},服务器返回的内容:{result.text}", "翻译")
+
+            if result.status_code != 200:
+                LogManager.error(f"翻译失败,状态码:{result.status_code},服务器返回的内容:{result.text}")
+                return None
+
+            json = result.json()
+            data = json.get("data")
+            return data
+        except Exception as e:
+            LogManager.method_error(f"翻译失败,报错的原因:{e}", "翻译失败异常")
+
+
+
+
+    # 翻译
+    @classmethod
+    def translationToChinese(cls, msg):
+        try:
+            param = {
+                "msg": msg,
+            }
+            url = "https://ai.yolozs.com/translationToChinese"
+            result = requests.post(url=url, json=param, verify=False)
+
+            LogManager.info(f"翻译 请求的参数:{param}", "翻译")
+            LogManager.info(f"翻译,状态码:{result.status_code},服务器返回的内容:{result.text}", "翻译")
+
+            if result.status_code != 200:
+                LogManager.error(f"翻译失败,状态码:{result.status_code},服务器返回的内容:{result.text}")
+                return None
+
+            json = result.json()
+            data = json.get("data")
+            return data
+        except Exception as e:
+            LogManager.method_error(f"翻译失败,报错的原因:{e}", "翻译失败异常")
+
+
+
+    # ai聊天
+    @classmethod
+    def chatToAi(cls, param):
+
+
+
+
+        # aiConfig = JsonUtils.read_json("aiConfig")
+        aiConfig = IOSAIStorage.load("aiConfig.json")
+
+
+
+
+        agentName = aiConfig.get("agentName")
+        guildName = aiConfig.get("guildName")
+        contactTool = aiConfig.get("contactTool", "")
+        contact = aiConfig.get("contact", "")
+
+        age = aiConfig.get("age", 20)
+        sex = aiConfig.get("sex", "女")
+        height = aiConfig.get("height", 160)
+        weight = aiConfig.get("weight", 55)
+        body_features = aiConfig.get("body_features", "")
+        nationality = aiConfig.get("nationality", "中国")
+        personality = aiConfig.get("personality", "")
+        strengths = aiConfig.get("strengths", "")
+
+
+
+
+        inputs = {
+            "name": agentName,
+            "Trade_union": guildName,
+            "contcat_method": contactTool,
+            "contcat_info": contact,
+            "age": age,
+            "sex": sex,
+            "height": height,
+            "weight": weight,
+            "body_features": body_features,
+            "nationality": nationality,
+            "personality": personality,
+            "strengths": strengths,
+        }
+
+        param["inputs"] = inputs
+
+        try:
+
+            # url = "https://ai.yolozs.com/chat"
+            url = "https://ai.yolozs.com/customchat"
+
+            result = requests.post(url=url, json=param,  verify=False)
+
+            LogManager.method_info(f"ai聊天的参数：{param}", "ai聊天")
+            print(f"ai聊天的参数：{param}")
+
+            json = result.json()
+            data = json.get("answer", "")
+            session_id = json.get("conversation_id", "")
+            LogManager.method_info(f"ai聊天返回的内容：{result.json()}", "ai聊天")
+
+            return data, session_id
+        except Exception as e:
+            LogManager.method_error(f"ai聊天失败,ai聊天出现异常,报错的原因:{e}", "ai聊天接口异常")

Utils/SubprocessKit.py

@@ -0,0 +1,24 @@
+import os
+import subprocess
+
+__all__ = ['check_output', 'popen', 'PIPE']
+
+# 模块级单例，导入时只创建一次
+if os.name == "nt":
+    _si = subprocess.STARTUPINFO()
+    _si.dwFlags |= subprocess.STARTF_USESHOWWINDOW
+    _si.wShowWindow = subprocess.SW_HIDE
+else:
+    _si = None
+
+PIPE = subprocess.PIPE
+
+def check_output(cmd, **kw):
+    if os.name == "nt":
+        kw.setdefault('startupinfo', _si)
+    return subprocess.check_output(cmd, **kw)
+
+def popen(*args, **kw):
+    if os.name == "nt":
+        kw.setdefault('startupinfo', _si)
+    return subprocess.Popen(*args, **kw)

Utils/TencentOCRUtils.py

@@ -0,0 +1,327 @@
+# -*- coding: utf-8 -*-
+import base64
+import hashlib
+import hmac
+import json
+import os
+import re
+import socket
+import time
+from datetime import datetime, timezone
+from http.client import HTTPSConnection
+from typing import Any, Dict, List, Optional
+
+Point = Dict[str, int]
+ItemPolygon = Dict[str, int]
+
+
+class TencentOCR:
+    """腾讯云 OCR 封装，自动从环境变量或配置文件加载密钥"""
+
+    @staticmethod
+    def _load_secret() -> Dict[str, str]:
+        # 优先从环境变量读取
+        sid = "AKIDXw86q6D8pJYZOEvOm25wZy96oIZcQ1OX"
+        skey = "ye7MNAj4ub5PVO2TmriLkwtc8QTItGPO"
+
+        # 如果没有，就尝试从 ~/.tencent_ocr.json 加载
+        if not sid or not skey:
+            cfg_path = os.path.expanduser("~/.tencent_ocr.json")
+            if os.path.exists(cfg_path):
+                with open(cfg_path, "r", encoding="utf-8") as f:
+                    cfg = json.load(f)
+                    sid = sid or cfg.get("secret_id")
+                    skey = skey or cfg.get("secret_key")
+
+        if not sid or not skey:
+            raise RuntimeError(
+                "❌ 未找到腾讯云 OCR 密钥，请设置环境变量 TENCENT_SECRET_ID / TENCENT_SECRET_KEY，"
+                "或在用户目录下创建 ~/.tencent_ocr.json（格式：{\"secret_id\":\"...\",\"secret_key\":\"...\"}）"
+            )
+
+        return {"secret_id": sid, "secret_key": skey}
+
+    @staticmethod
+    def _hmac_sha256(key: bytes, msg: str) -> bytes:
+        return hmac.new(key, msg.encode("utf-8"), hashlib.sha256).digest()
+
+    @staticmethod
+    def _strip_data_uri_prefix(b64: str) -> str:
+        if "," in b64 and b64.strip().lower().startswith("data:"):
+            return b64.split(",", 1)[1]
+        return b64
+
+    @staticmethod
+    def _now_ts_and_date():
+        ts = int(time.time())
+        date = datetime.fromtimestamp(ts, tz=timezone.utc).strftime("%Y-%m-%d")
+        return ts, date
+
+    @staticmethod
+    def recognize(
+        *,
+        image_path: Optional[str] = None,
+        image_bytes: Optional[bytes] = None,
+        image_url: Optional[str] = None,
+        region: Optional[str] = None,
+        token: Optional[str] = None,
+        action: str = "GeneralBasicOCR",
+        version: str = "2018-11-19",
+        service: str = "ocr",
+        host: str = "ocr.tencentcloudapi.com",
+        timeout: int = 15,
+    ) -> Dict[str, Any]:
+        """
+        调用腾讯云 OCR，三选一：image_path / image_bytes / image_url
+        自动加载密钥（优先环境变量 -> ~/.tencent_ocr.json）
+        """
+        # 读取密钥
+        sec = TencentOCR._load_secret()
+        secret_id = sec["secret_id"]
+        secret_key = sec["secret_key"]
+
+        assert sum(v is not None for v in (image_path, image_bytes, image_url)) == 1, \
+            "必须且只能提供 image_path / image_bytes / image_url 之一"
+
+        # 1. payload
+        payload: Dict[str, Any] = {}
+        if image_url:
+            payload["ImageUrl"] = image_url
+        else:
+            if image_bytes is None:
+                with open(image_path, "rb") as f:
+                    image_bytes = f.read()
+            img_b64 = base64.b64encode(image_bytes).decode("utf-8")
+            img_b64 = TencentOCR._strip_data_uri_prefix(img_b64)
+            payload["ImageBase64"] = img_b64
+
+        payload_str = json.dumps(payload, ensure_ascii=False, separators=(",", ":"))
+
+        # 2. 参数准备
+        algorithm = "TC3-HMAC-SHA256"
+        http_method = "POST"
+        canonical_uri = "/"
+        canonical_querystring = ""
+        content_type = "application/json; charset=utf-8"
+        signed_headers = "content-type;host;x-tc-action"
+
+        timestamp, date = TencentOCR._now_ts_and_date()
+        credential_scope = f"{date}/{service}/tc3_request"
+
+        # 3. 规范请求串
+        canonical_headers = (
+            f"content-type:{content_type}\n"
+            f"host:{host}\n"
+            f"x-tc-action:{action.lower()}\n"
+        )
+        hashed_request_payload = hashlib.sha256(payload_str.encode("utf-8")).hexdigest()
+        canonical_request = (
+            f"{http_method}\n{canonical_uri}\n{canonical_querystring}\n"
+            f"{canonical_headers}\n{signed_headers}\n{hashed_request_payload}"
+        )
+
+        # 4. 签名
+        hashed_canonical_request = hashlib.sha256(canonical_request.encode("utf-8")).hexdigest()
+        string_to_sign = (
+            f"{algorithm}\n{timestamp}\n{credential_scope}\n{hashed_canonical_request}"
+        )
+        secret_date = TencentOCR._hmac_sha256(("TC3" + secret_key).encode("utf-8"), date)
+        secret_service = hmac.new(secret_date, service.encode("utf-8"), hashlib.sha256).digest()
+        secret_signing = hmac.new(secret_service, b"tc3_request", hashlib.sha256).digest()
+        signature = hmac.new(secret_signing, string_to_sign.encode("utf-8"), hashlib.sha256).hexdigest()
+
+        authorization = (
+            f"{algorithm} "
+            f"Credential={secret_id}/{credential_scope}, "
+            f"SignedHeaders={signed_headers}, "
+            f"Signature={signature}"
+        )
+
+        # 5. headers
+        headers = {
+            "Authorization": authorization,
+            "Content-Type": content_type,
+            "Host": host,
+            "X-TC-Action": action,
+            "X-TC-Timestamp": str(timestamp),
+            "X-TC-Version": version,
+        }
+        if region:
+            headers["X-TC-Region"] = region
+        if token:
+            headers["X-TC-Token"] = token
+
+        # 6. 发请求
+        try:
+            conn = HTTPSConnection(host, timeout=timeout)
+            conn.request("POST", "/", body=payload_str.encode("utf-8"), headers=headers)
+            resp = conn.getresponse()
+            raw = resp.read().decode("utf-8", errors="replace")
+            try:
+                data = json.loads(raw)
+            except Exception:
+                data = {"NonJSONBody": raw}
+            return {
+                "http_status": resp.status,
+                "http_reason": resp.reason,
+                "headers": dict(resp.getheaders()),
+                "body": data,
+            }
+        except socket.gaierror as e:
+            return {"error": "DNS_RESOLUTION_FAILED", "detail": str(e)}
+        except socket.timeout:
+            return {"error": "NETWORK_TIMEOUT", "detail": f"Timeout after {timeout}s"}
+        except Exception as e:
+            return {"error": "REQUEST_FAILED", "detail": str(e)}
+        finally:
+            try:
+                conn.close()
+            except Exception:
+                pass
+
+    @staticmethod
+    def _norm(s: str) -> str:
+        return (s or "").strip().lstrip("@").lower()
+
+    @staticmethod
+    def _rect_from_polygon(poly: List[Point]) -> Optional[ItemPolygon]:
+        if not poly:
+            return None
+        xs = [p["X"] for p in poly]
+        ys = [p["Y"] for p in poly]
+        return {"X": min(xs), "Y": min(ys), "Width": max(xs) - min(xs), "Height": max(ys) - min(ys)}
+
+    @classmethod
+    def find_last_name_bbox(cls, ocr: Dict[str, Any], name: str) -> Optional[Dict[str, Any]]:
+        """
+        从 OCR JSON 中找到指定名字的“最后一次”出现并返回坐标信息。
+        :param ocr: 完整 OCR JSON（含 Response.TextDetections）
+        :param name: 前端传入的名字，比如 'lee39160'
+        :return: dict 或 None，例如：
+            {
+                "index": 21,
+                "text": "lee39160",
+                "item": {"X": 248, "Y": 1701, "Width": 214, "Height": 49},
+                "polygon": [...],
+                "center": {"x": 355.0, "y": 1725.5}
+            }
+        """
+        dets = (ocr.get("body") or ocr).get("Response", {}).get("TextDetections", [])
+        if not dets or not name:
+            return None
+
+        target = cls._norm(name)
+        found = -1
+
+        # 从后往前找最后一个严格匹配
+        for i in range(len(dets) - 1, -1, -1):
+            txt = cls._norm(dets[i].get("DetectedText", ""))
+            if txt == target:
+                found = i
+                break
+
+        # 兜底：再匹配原始文本（可能带 @）
+        if found == -1:
+            for i in range(len(dets) - 1, -1, -1):
+                raw = (dets[i].get("DetectedText") or "").strip().lower()
+                if raw.lstrip("@") == target:
+                    found = i
+                    break
+
+        if found == -1:
+            return None
+
+        det = dets[found]
+        item: Optional[ItemPolygon] = det.get("ItemPolygon")
+        poly: List[Point] = det.get("Polygon") or []
+
+        # 没有 ItemPolygon 就从 Polygon 算
+        if not item:
+            item = cls._rect_from_polygon(poly)
+            if not item:
+                return None
+
+        center = {"x": item["X"] + item["Width"] / 2.0, "y": item["Y"] + item["Height"] / 2.0}
+
+        return {
+            "index": found,
+            "text": det.get("DetectedText", ""),
+            "item": item,
+            "polygon": poly,
+            "center": center,
+        }
+
+    @staticmethod
+    def _get_detections(ocr: Dict[str, Any]) -> List[Dict[str, Any]]:
+        """兼容含 body 层的 OCR 结构，提取 TextDetections 列表"""
+        return (ocr.get("body") or ocr).get("Response", {}).get("TextDetections", []) or []
+
+    @staticmethod
+    def _norm_txt(s: str) -> str:
+        """清洗文本：去空格"""
+        return (s or "").strip()
+
+    @classmethod
+    def slice_texts_between(
+            cls,
+            ocr: Dict[str, Any],
+            start_keyword: str = "切换账号",
+            end_keyword: str = "添加账号",
+            *,
+            username_like: bool = False,  # True 时只保留像用户名的文本
+            min_conf: int = 0  # 置信度下限
+    ) -> List[Dict[str, Any]]:
+        """
+        返回位于 start_keyword 与 end_keyword 之间的所有文本项（不含两端），
+        每项保留原始 DetectedText、Confidence、ItemPolygon 等信息。
+        """
+        dets = cls._get_detections(ocr)
+        if not dets:
+            return []
+
+        # 找“切换账号”最后一次出现的下标
+        start_idx = -1
+        for i, d in enumerate(dets):
+            txt = cls._norm_txt(d.get("DetectedText", ""))
+            if txt == start_keyword:
+                start_idx = i
+
+        # 找“添加账号”第一次出现的下标
+        end_idx = -1
+        for i, d in enumerate(dets):
+            txt = cls._norm_txt(d.get("DetectedText", ""))
+            if txt == end_keyword:
+                end_idx = i
+                break
+
+        if start_idx == -1 or end_idx == -1 or end_idx <= start_idx:
+            return []
+
+        # 提取两者之间的内容
+        mid = []
+        for d in dets[start_idx + 1:end_idx]:
+            if int(d.get("Confidence", 0)) < min_conf:
+                continue
+            txt = cls._norm_txt(d.get("DetectedText", ""))
+            if not txt:
+                continue
+            mid.append(d)
+
+        if not username_like:
+            return mid
+
+        # 只保留像用户名的文本
+        pat = re.compile(r"^[A-Za-z0-9_.-]{3,}$")
+        filtered = [d for d in mid if pat.match(cls._norm_txt(d.get("DetectedText", "")))]
+        return filtered
+
+
+
+
+if __name__ == "__main__":
+    result = TencentOCR.recognize(
+        image_path=r"C:\Users\zhangkai\Desktop\last-item\iosai\test.png",
+        action="GeneralAccurateOCR",
+    )
+    print(json.dumps(result, ensure_ascii=False, indent=2))
+

Utils/ThreadManager.py

@@ -0,0 +1,226 @@
+# -*- coding: utf-8 -*-
+
+import threading
+import ctypes
+import inspect
+import time
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from typing import Dict, Optional, List, Tuple, Any
+
+from Utils.LogManager import LogManager
+
+
+def _raise_async_exception(tid: int, exc_type) -> int:
+    if not inspect.isclass(exc_type):
+        raise TypeError("exc_type must be a class")
+    return ctypes.pythonapi.PyThreadState_SetAsyncExc(
+        ctypes.c_long(tid), ctypes.py_object(exc_type)
+    )
+
+
+def _kill_thread_by_tid(tid: Optional[int]) -> bool:
+    if tid is None:
+        return False
+    res = _raise_async_exception(tid, SystemExit)
+    if res == 0:
+        return False
+    if res > 1:
+        _raise_async_exception(tid, None)
+        raise SystemError("PyThreadState_SetAsyncExc affected multiple threads; reverted.")
+    return True
+
+
+class ThreadManager:
+    """
+    - add(udid, thread_or_target, *args, **kwargs) -> (code, msg)
+    - stop(udid, join_timeout=2.0, retries=5, wait_step=0.2) -> (code, msg)   # 强杀
+    - batch_stop(udids, join_timeout_each=2.0, retries_each=5, wait_step_each=0.2) -> (code, msg)
+    - get_thread / get_tid / is_running / list_udids
+    """
+    _threads: Dict[str, threading.Thread] = {}
+    _lock = threading.RLock()
+
+    # ========== 基础 ==========
+    @classmethod
+    def add(cls, udid: str, thread_or_target: Any, *args, **kwargs) -> Tuple[int, str]:
+        """
+        兼容两种用法：
+          1) add(udid, t)                        # t 是 threading.Thread 实例
+          2) add(udid, target, *args, **kwargs)  # target 是可调用
+        返回：(200, "创建任务成功") / (1001, "任务已存在") / (1001, "创建任务失败")
+        """
+        with cls._lock:
+            exist = cls._threads.get(udid)
+            if exist and exist.is_alive():
+                return 1001, "任务已存在"
+
+            if isinstance(thread_or_target, threading.Thread):
+                t = thread_or_target
+                try:
+                    t.daemon = True
+                except Exception:
+                    pass
+                if not t.name:
+                    t.name = f"task-{udid}"
+
+                # 包装 run，退出时从表移除
+                orig_run = t.run
+                def run_wrapper():
+                    try:
+                        orig_run()
+                    finally:
+                        with cls._lock:
+                            if cls._threads.get(udid) is t:
+                                cls._threads.pop(udid, None)
+                t.run = run_wrapper  # type: ignore
+
+            else:
+                target = thread_or_target
+                def _wrapper():
+                    try:
+                        target(*args, **kwargs)
+                    finally:
+                        with cls._lock:
+                            cur = cls._threads.get(udid)
+                            if cur is threading.current_thread():
+                                cls._threads.pop(udid, None)
+                t = threading.Thread(target=_wrapper, daemon=True, name=f"task-{udid}")
+
+            try:
+                t.start()
+            except Exception:
+                return 1001, "创建任务失败"
+
+            cls._threads[udid] = t
+            # 保留你原有的创建成功日志
+            try:
+                LogManager.method_info(f"创建任务成功 [{udid}]，线程ID={t.ident}", "task")
+            except Exception:
+                pass
+            return 200, "创建任务成功"
+
+    @classmethod
+    def get_thread(cls, udid: str) -> Optional[threading.Thread]:
+        with cls._lock:
+            return cls._threads.get(udid)
+
+    @classmethod
+    def get_tid(cls, udid: str) -> Optional[int]:
+        t = cls.get_thread(udid)
+        return t.ident if t else None
+
+    @classmethod
+    def is_running(cls, udid: str) -> bool:
+        t = cls.get_thread(udid)
+        return bool(t and t.is_alive())
+
+    @classmethod
+    def list_udids(cls) -> List[str]:
+        with cls._lock:
+            return list(cls._threads.keys())
+
+    # ========== 内部：强杀一次 ==========
+
+    @classmethod
+    def _stop_once(cls, udid: str, join_timeout: float, retries: int, wait_step: float) -> bool:
+        """
+        对指定 udid 执行一次强杀流程；返回 True=已停止/不存在，False=仍存活或被拒。
+        """
+        with cls._lock:
+            t = cls._threads.get(udid)
+
+        if not t:
+            return True  # 视为已停止
+
+        main_tid = threading.main_thread().ident
+        cur_tid = threading.get_ident()
+        if t.ident in (main_tid, cur_tid):
+            return False
+
+        try:
+            _kill_thread_by_tid(t.ident)
+        except Exception:
+            pass
+
+        if join_timeout < 0:
+            join_timeout = 0.0
+        t.join(join_timeout)
+
+        while t.is_alive() and retries > 0:
+            evt = threading.Event()
+            evt.wait(wait_step)
+            retries -= 1
+
+        dead = not t.is_alive()
+        if dead:
+            with cls._lock:
+                if cls._threads.get(udid) is t:
+                    cls._threads.pop(udid, None)
+        return dead
+
+    # ========== 对外：stop / batch_stop（均返回二元组） ==========
+
+    @classmethod
+    def stop(cls, udid: str, join_timeout: float = 2.0,
+             retries: int = 5, wait_step: float = 0.2) -> Tuple[int, str]:
+        """
+        强杀单个：返回 (200, "stopped") 或 (1001, "failed")
+        """
+        ok = cls._stop_once(udid, join_timeout, retries, wait_step)
+        if ok:
+            return 200, "stopped"
+        else:
+            return 1001, "failed"
+
+    @classmethod
+    def batch_stop(cls, udids: List[str]) -> Tuple[int, str, List[str]]:
+        """
+        并行批量停止（简化版）：
+          - 只接收 udids 参数
+          - 其他参数写死：join_timeout=2.0, retries=5, wait_step=0.2
+          - 所有设备同时执行，失败的重试 3 轮，每轮间隔 1 秒
+          - 返回:
+              (200, "停止任务成功", [])
+              (1001, "停止任务失败", [失败udid...])
+        """
+        if not udids:
+            return 200, "停止任务成功", []
+
+        join_timeout = 2.0
+        retries = 5
+        wait_step = 0.2
+        retry_rounds = 3
+        round_interval = 1.0
+
+        def _stop_one(u: str) -> Tuple[str, bool]:
+            ok = cls._stop_once(u, join_timeout, retries, wait_step)
+            return u, ok
+
+        # === 第一轮：并行执行所有设备 ===
+        fail: List[str] = []
+        with ThreadPoolExecutor(max_workers=len(udids)) as pool:
+            futures = [pool.submit(_stop_one, u) for u in udids]
+            for f in as_completed(futures):
+                u, ok = f.result()
+                if not ok:
+                    fail.append(u)
+
+        # === 对失败的设备重试 3 轮（每轮间隔 1 秒） ===
+        for _ in range(retry_rounds):
+            if not fail:
+                break
+            time.sleep(round_interval)
+            remain: List[str] = []
+            with ThreadPoolExecutor(max_workers=len(fail)) as pool:
+                futures = [pool.submit(_stop_one, u) for u in fail]
+                for f in as_completed(futures):
+                    u, ok = f.result()
+                    if not ok:
+                        remain.append(u)
+            fail = remain
+
+        # === 返回结果 ===
+        if not fail:
+            return 200, "停止任务成功", []
+        else:
+            return 1001, "停止任务失败", fail