fix: schema 迁移幂等兜底——create_all 已建列而 schema_version 未记录时重复 ALTER 报 duplicate column，遇错回滚并照记版本自愈

典型场景：create_all 已按当前模型把列/表直接建好（如 perms、device.model），
而 schema_version 又因历史中断没记录，导致每次启动重复 ALTER 报错。
duplicate column name 说明列已存在=迁移目标已达成：回滚本次语句后仍记录
版本号，一次启动即自愈；其它异常才中止本批迁移。

.gitignore

@@ -45,3 +45,6 @@ bin/adb/*
 # 数据备份与损坏库（运维临时文件，不入库）
 data/db_backup_*/
 data/*.corrupt_*
+data/users.db*
+data/users.db-wal
+data/users.db-shm

README.md

@@ -73,7 +73,18 @@ python web_server.py
 ```
 platform-tools/
 ├── config.py                    # 根配置（部署配置统一从 .env 读，模板见 .env.example）
-├── web_server.py                # Flask 入口（API + 登录 + 单页应用）
+├── web_server.py                # Flask 入口（app 装配 + 蓝图注册 + 启动，193 行）
+├── web/                         # Web 层蓝图包（按功能域拆分，路由都在这里）
+│   ├── auth.py                  #   登录/CSRF/权限装饰器/页面路由（/、/wall）
+│   ├── monitor.py               #   状态/运行控制/设备操作/远程看屏
+│   ├── tasks_api.py             #   任务计划/分组/自定义动作/元素抓取
+│   ├── admin_api.py             #   用户管理/日志
+│   ├── tools_api.py             #   adb 终端/剪贴板注入/应用版本
+│   ├── devices_api.py           #   设备池管理
+│   ├── apks_api.py              #   应用管理
+│   ├── tailscale_api.py         #   Tailscale 管理
+│   ├── common.py                #   跨模块共享工具（合并设备列表/屏幕状态）
+│   └── context.py               #   共享对象注入（mgr/apk_mgr/device_pool）
 ├── requirements.txt             # Python 依赖清单
 │
 ├── core/                        # 核心基础设施层
@@ -247,7 +258,7 @@ self.set_progress(done=5, total=80, unit="视频",
 
 | Tab | 功能 | 可见性 |
 |-----|------|--------|
-| 监控 | 设备状态大屏：在线/离线、型号、运行任务、当前动作、进度条、前台 App、截图、勾选批量操作（亮屏/息屏/停止） | 所有登录用户（设备操作按钮需"设备控制"权限） |
+| 监控 | 设备状态大屏：在线/离线、型号、运行任务、当前动作、进度条、前台 App、截图、勾选批量操作（亮屏/息屏/停止）；导航栏「📺 大屏」打开全屏监控墙（/wall，缩略图+统计+时钟，挂墙/电视用） | 所有登录用户（设备操作按钮需"设备控制"权限） |
 | 任务 | 子分栏：任务计划（CRUD/启用停用/立即执行/下次运行时间/**离线设备自动跳过**）、自定义动作（打包复用） | 所有登录用户可看，写操作需"任务管理"权限 |
 | 分组 | 设备分组管理：创建/编辑/删除分组 | 所有登录用户可看，写操作需"任务管理"权限 |
 | 日志 | 实时日志查看：按模块切换（core/task/web/action） | 需"日志查看"权限 |

config.py

@@ -82,3 +82,10 @@ USB_ADB_PORT = int(_env("USB_ADB_PORT", "5037"))
 # 安全：密钥用环境变量/.env 注入，不要写死在代码或提交到 git。
 TAILSCALE_API_KEY = _env("TAILSCALE_API_KEY", "")   # 写入 .env，不要提交到 git
 TAILSCALE_TAILNET = _env("TAILSCALE_TAILNET", "")
+
+# ================== 设备自动发现 ==================
+# 定时扫描网段中开放 adb 5555 的设备 → 待连接池（用户确认后才加入正式池）。
+# 网段默认：局域网 + Tailscale；可在工具页设备池面板修改（存 app_meta）。
+DISCOVERY_PORT = int(_env("DISCOVERY_PORT", "5555"))
+DISCOVERY_SUBNETS = ["192.168.20.0/24", "100.100.10.0/24"]
+DISCOVERY_INTERVAL = int(_env("DISCOVERY_INTERVAL", "60"))

core/adb_helper.py

@@ -19,17 +19,18 @@ _ADB_LOCK = threading.Lock()
 _ADB_TIMEOUT = 30
 
 
-def _adb(*args):
+def _adb(*args, timeout=_ADB_TIMEOUT):
     """执行 adb 命令，返回 (stdout+stderr) 文本。不用 shell=True，避免子进程环境问题。
 
     用 bytes 模式自己解码（Windows 下 subprocess text=True 会用 GBK 读 adb 输出，
     遇到非 GBK 字节会崩溃）。
     带 30s 超时：adb connect 到不可达地址可能挂很久，超时返回空串由调用方处理。
+    timeout 可覆盖（扫描验证等非关键路径用短超时快速失败）。
     """
     try:
-        r = subprocess.run([ADB_PATH, *args], capture_output=True, timeout=_ADB_TIMEOUT)
+        r = subprocess.run([ADB_PATH, *args], capture_output=True, timeout=timeout)
     except subprocess.TimeoutExpired:
-        _log.warning(f"adb {' '.join(args)} 超时 {_ADB_TIMEOUT}s")
+        _log.warning(f"adb {' '.join(args)} 超时 {timeout}s")
         return ""
     return _decode(r)
 
@@ -157,16 +158,18 @@ def _try_connect(remote_adb_url, retries):
     return False
 
 
-def adb_connect_light(remote_adb_url):
-    """轻量 adb connect（扫描专用）：单次尝试，不重试，绝不 kill-server。
+def adb_connect_light(remote_adb_url, timeout=5):
+    """轻量 adb connect（扫描/验证专用）：单次尝试，不重试，绝不 kill-server。
 
     与 adb_connect 的区别：
       - 不重试：失败立即返回 False
       - 不 kill-server：避免断开其他 worker 正在使用的 ADB 连接
+      - 短超时（默认 5s）：验证场景（设备发现）连不上的主机快速放弃，
+        避免每台卡 30s 拖慢整轮发现并长时间占用全局 adb 锁
     用于前台 App 扫描等非关键路径，连不上就跳过，不影响正在运行的任务。
     """
     with _ADB_LOCK:
-        out = _adb("connect", remote_adb_url)
+        out = _adb("connect", remote_adb_url, timeout=timeout)
         if "connected" in out.lower() and "failed" not in out.lower():
             return True
         return False

core/clipboard_helper.py

@@ -0,0 +1,69 @@
+"""剪贴板注入公共模块（ClipInject APK 通道）。
+
+背景：Android 10+ 禁止后台（atx-agent/shell）写剪贴板——u2.set_clipboard
+调用"成功"但内容被系统静默丢弃（Android 12/13 实测）。ClipInject
+（com.example.clipinject，用户自研 APK）通过 am start 启动透明 Activity，
+窗口聚焦后 setPrimaryClip；shell 身份启动 Activity 不受后台启动限制
+（广播方式在 MIUI 会被 Background activity start 拦截，必须用 am start）。
+
+工具页（web/tools_api.py）与任务执行器（tasks/generic/task.py）共用本模块。
+"""
+import base64
+import subprocess
+import time
+from concurrent.futures import ThreadPoolExecutor
+
+from config import ADB_PATH
+from core.adb_helper import adb_connect
+from core.logger import get_logger
+
+_log = get_logger("core.clip")
+
+_CLIP_PACKAGE = "com.example.clipinject"
+_CLIP_ACTIVITY = "com.example.clipinject/.ClipActivity"
+
+
+def inject_clipboard(serial, text, d=None):
+    """向设备剪贴板注入文字，返回 (ok, msg)。
+
+    - d：可选，任务执行器已持有 u2 Device 时传入复用（跳过重复连接），
+      读回验证直接用它；不传则临时 u2.connect（工具页场景，带超时保护）
+    - IP:port 设备先 adb connect（已连接自动跳过；绝不 disconnect，红线）
+    - 未装 ClipInject / 读回不一致都会明确报错（不再静默失败）
+    """
+    import uiautomator2 as u2
+    if ":" in serial:
+        try:
+            adb_connect(serial)
+        except Exception as e:
+            return False, f"adb 连接失败: {e}"
+    b64 = base64.b64encode(text.encode("utf-8")).decode()
+    # 1. am start 透明 Activity 写剪贴板（shell 身份，不受后台启动限制）
+    try:
+        r = subprocess.run(
+            [ADB_PATH, "-s", serial, "shell", "am", "start",
+             "-n", _CLIP_ACTIVITY, "--es", "text_b64", b64],
+            capture_output=True, timeout=30)
+        out = ((r.stdout or b"") + (r.stderr or b"")).decode(errors="replace")
+        if "does not exist" in out or "unable to resolve Intent" in out:
+            return False, f"设备未安装 ClipInject（{_CLIP_PACKAGE}），请先安装"
+        if "Error" in out or ("Starting" not in out and r.returncode != 0):
+            return False, f"am start 失败: {out.strip()[:120]}"
+    except subprocess.TimeoutExpired:
+        return False, "am start 超时（adb 无响应）"
+    except Exception as e:
+        return False, f"{type(e).__name__}: {str(e)[:120]}"
+    # 2. 读回验证（等透明 Activity 完成写入；u2 读剪贴板在 Android 12 实测可用）
+    time.sleep(0.5)
+    try:
+        if d is None:
+            with ThreadPoolExecutor(max_workers=1) as pool:
+                d = pool.submit(u2.connect, serial).result(timeout=30)
+        with ThreadPoolExecutor(max_workers=1) as pool:
+            got = pool.submit(lambda: d.clipboard).result(timeout=15)
+        if got == text:
+            return True, "已注入"
+        return False, f"剪贴板读回不一致（写入可能被拒）: {str(got)[:60]!r}"
+    except Exception as e:
+        # 读回不可用（旧版 u2/连接失败）时按写入成功处理，避免误报，但带上具体原因
+        return True, f"已注入（读回验证不可用: {type(e).__name__}: {str(e)[:80]}）"

core/device_discovery.py

@@ -0,0 +1,401 @@
+"""设备自动发现：扫描网段中开放 adb 5555 的设备 → 待连接池（pending）。
+
+流程：socket 并发探测 5555（标准库，不碰 adb）→ 剔除已在设备池的 serial →
+串行 adb 验证（adb_connect_light，内部全局锁）→ 用 `adb devices` 的
+state=="device" 过滤（排除 unauthorized/offline，connect 输出不可信）→
+写入 pending_device 表。**扫描只验证、不自动连接入池**——用户在前端确认后
+才调 device_pool.add_device + adb_connect（见 web/devices_api.py）。
+
+安全红线：绝不 kill-server / 绝不 disconnect（与全项目一致）。
+
+配置存 app_meta KV 表（discovery_enabled/subnets/interval/port），定时线程
+每轮重读，开关/周期/网段改动即时生效无需重启。
+"""
+import ipaddress
+import json
+import socket
+import threading
+from concurrent.futures import ThreadPoolExecutor
+from datetime import datetime
+
+from config import (USB_ADB_HOST,
+                    DISCOVERY_PORT, DISCOVERY_SUBNETS, DISCOVERY_INTERVAL)
+from core.adb_helper import _adb, adb_connect_light
+from core.logger import get_logger
+from core.models import db, Device, PendingDevice
+
+_log = get_logger("core.disc")
+
+# 扫描配置键（app_meta）
+_K_ENABLED = "discovery_enabled"
+_K_SUBNETS = "discovery_subnets"
+_K_INTERVAL = "discovery_interval"
+_K_PORT = "discovery_port"
+
+# 单网段主机数上限（防误配 /8 之类），超过截断并告警
+_MAX_HOSTS_PER_SUBNET = 1024
+# socket 探测并发数与单 IP 超时
+_PROBE_WORKERS = 64
+_PROBE_TIMEOUT = 0.4
+
+_app = None
+_scan_lock = threading.Lock()     # 定时/手动扫描互斥
+_stop_event = threading.Event()   # shutdown 用
+_scanning = False                 # 状态快照（API/前端）
+_last_scan = None                 # (时间串, 开放数, 可连数, 新增数)
+_last_error = ""
+
+
+def _ctx():
+    """后台线程访问 db 时自行推 app context（仿 device_pool._ctx）。"""
+    return _app.app_context() if _app else None
+
+
+def _fmt(ts=None):
+    return (ts or datetime.now()).strftime("%Y-%m-%d %H:%M")
+
+
+# ================== 配置读写 ==================
+def get_settings():
+    """读发现配置（app_meta，缺键用 config 默认值补齐）。"""
+    with _ctx():
+        def _get(key, default):
+            v = db.session.execute(
+                db.text("SELECT value FROM app_meta WHERE key=:k"), {"k": key}).scalar()
+            return v if v is not None else default
+        try:
+            subnets = json.loads(_get(_K_SUBNETS, "[]")) or DISCOVERY_SUBNETS
+        except Exception:
+            subnets = DISCOVERY_SUBNETS
+        return {
+            "enabled": _get(_K_ENABLED, "1") == "1",   # 默认开启
+            "subnets": subnets,
+            "interval": int(_get(_K_INTERVAL, str(DISCOVERY_INTERVAL)) or DISCOVERY_INTERVAL),
+            "port": int(_get(_K_PORT, str(DISCOVERY_PORT)) or DISCOVERY_PORT),
+        }
+
+
+def save_settings(enabled=None, subnets=None, interval=None, port=None):
+    """写发现配置（部分字段更新）。subnets 逐项校验 CIDR，非法返回 (False, 原因)。"""
+    if subnets is not None:
+        clean = []
+        for s in subnets:
+            s = (s or "").strip()
+            if not s:
+                continue
+            try:
+                ipaddress.ip_network(s, strict=False)
+            except ValueError:
+                return False, f"网段格式错误: {s}"
+            clean.append(s)
+        subnets = clean
+    try:
+        if interval is not None and (int(interval) < 10 or int(interval) > 3600):
+            return False, "扫描周期需在 10-3600 秒之间"
+        if port is not None and (int(port) < 1 or int(port) > 65535):
+            return False, "端口不合法"
+    except (TypeError, ValueError):
+        return False, "参数不合法"
+    with _ctx():
+        def _put(key, value):
+            db.session.execute(
+                db.text("INSERT OR REPLACE INTO app_meta(key,value) VALUES(:k,:v)"),
+                {"k": key, "v": str(value)})
+        if enabled is not None:
+            _put(_K_ENABLED, "1" if enabled else "0")
+        if subnets is not None:
+            _put(_K_SUBNETS, json.dumps(subnets))
+        if interval is not None:
+            _put(_K_INTERVAL, str(int(interval)))
+        if port is not None:
+            _put(_K_PORT, str(int(port)))
+        db.session.commit()
+    return True, "已保存"
+
+
+# ================== 网段展开与端口探测 ==================
+def _local_ips():
+    """本机自身 IP 集合（尽力而为）：扫描时排除，避免探测到自己的 5555。
+
+    优先 `hostname -I`（Linux/macOS 支持，一行空格分隔多 IP）；不支持/失败的
+    平台退回 socket.getaddrinfo 枚举。关键：外部命令必须用 bytes 收——Windows
+    上 git-bash 的 coreutils hostname 不支持 -I，会把 GBK 报错写进 stderr，
+    text=True 在 subprocess 后台读线程里 utf-8 严格解码会直接炸线程（主线程
+    try/except 接不住异步线程异常）。
+    """
+    import subprocess
+    ips = set()
+    try:
+        r = subprocess.run(["hostname", "-I"], capture_output=True, timeout=3)
+        if r.returncode == 0:
+            ips.update(p for p in
+                       r.stdout.decode("utf-8", errors="ignore").split() if p)
+    except Exception:
+        pass
+    if not ips:  # 兜底：主机名解析出的接口 IPv4
+        try:
+            for info in socket.getaddrinfo(socket.gethostname(), None):
+                ip = info[4][0]
+                if ":" not in ip:
+                    ips.add(ip)
+        except Exception:
+            pass
+    return ips
+
+
+def _expand_subnets(subnets, max_hosts=_MAX_HOSTS_PER_SUBNET):
+    """CIDR 列表 → IP 列表。排除 220 自身（USB_ADB_HOST）与本机 IP；
+    非法网段跳过记日志；单网段超过 max_hosts 截断并告警。"""
+    self_ips = {USB_ADB_HOST} | _local_ips()
+    ips = []
+    for cidr in subnets:
+        try:
+            net = ipaddress.ip_network((cidr or "").strip(), strict=False)
+        except ValueError:
+            _log.warning(f"发现: 跳过非法网段 {cidr}")
+            continue
+        hosts = [str(h) for h in net.hosts()
+                 if str(h) not in self_ips]
+        if len(hosts) > max_hosts:
+            _log.warning(f"发现: 网段 {cidr} 主机数 {len(hosts)} 超过上限，截断前 {max_hosts}")
+            hosts = hosts[:max_hosts]
+        ips.extend(hosts)
+    return ips
+
+
+def _probe_port(ip, port, timeout=_PROBE_TIMEOUT):
+    """单 IP 端口探测（标准库 socket，超时/拒绝/不可达一律 False）。"""
+    try:
+        with socket.create_connection((ip, port), timeout=timeout):
+            return True
+    except Exception:
+        return False
+
+
+def _probe_open(ips, port, workers=_PROBE_WORKERS):
+    """并发探测，返回开放端口的主机列表。"""
+    if not ips:
+        return []
+    with ThreadPoolExecutor(max_workers=workers) as ex:
+        results = list(ex.map(lambda ip: (ip, _probe_port(ip, port)), ips))
+    return [ip for ip, ok in results if ok]
+
+
+# ================== adb devices 解析 ==================
+def _parse_adb_devices(out):
+    """解析 `adb devices` 输出 → state=="device" 的 serial 集合。
+
+    只看 connect 输出不可靠（未授权设备也返回 connected），必须用 state 过滤。
+    """
+    devices = set()
+    for line in (out or "").splitlines()[1:]:
+        parts = line.split()
+        if len(parts) >= 2 and parts[0] and not parts[0].startswith("*"):
+            if parts[1] == "device":
+                devices.add(parts[0])
+    return devices
+
+
+# ================== 扫描 ==================
+def scan_once(manual=False):
+    """执行一轮扫描。返回 (ok, result_dict)；后台线程/API 调用。"""
+    global _scanning, _last_scan, _last_error
+    if not _scan_lock.acquire(blocking=False):
+        return False, {"error": "扫描进行中"}
+    _scanning = True
+    try:
+        settings = get_settings()
+        port = settings["port"]
+        subnets = settings["subnets"]
+        if not subnets:
+            _last_error = "未配置扫描网段"
+            return True, {"found": 0, "verified": 0, "new": 0, "error": _last_error}
+
+        # 1. socket 并发探测（不碰 adb，把几百台缩小到开放端口量级）
+        open_ips = _probe_open(_expand_subnets(subnets), port)
+        candidates = {f"{ip}:{port}" for ip in open_ips}
+
+        with _ctx():
+            # 2. 剔除已在正式设备池的 serial
+            configured = set(device_pool_list_configured())
+            candidates -= configured
+
+            # 3. 串行 adb 验证：已连接的直接跳过（零成本），其余 adb_connect_light
+            already = _parse_adb_devices(_adb("devices"))
+            for serial in candidates - already:
+                adb_connect_light(serial)  # 内部全局锁串行；失败无妨，下面按 state 过滤
+
+            # 4. state==device 过滤（排除 unauthorized/offline）
+            verified = _parse_adb_devices(_adb("devices")) & candidates
+
+            # 5. 写 pending：新 → 插入；已有 → 更新 last_seen
+            now = _fmt()
+            existing = {p.serial for p in PendingDevice.query.all()}
+            added = 0
+            for serial in verified:
+                source = "tailscale" if serial.split(":")[0].startswith("100.") else "lan"
+                if serial in existing:
+                    PendingDevice.query.filter_by(serial=serial).update(
+                        {"last_seen": now})
+                else:
+                    db.session.add(PendingDevice(serial=serial, source=source,
+                                                 first_seen=now, last_seen=now))
+                    added += 1
+            db.session.commit()
+            # 6. 正式池断联设备自动重连：adb connect 会因 WiFi 波动/设备重启/
+            #    adb 服务重启而断开——扫描线程每轮顺带重试（幂等轻量，内部
+            #    全局锁串行），连上即恢复在线，无需人工干预。pending 池是给
+            #    「未授权新设备」的，正式池设备断联不进 pending，而是自动重连。
+            back = _reconnect_offline(configured)
+            _log.info(f"发现: 探测开放 {len(open_ips)} 台，可连 {len(verified)} 台，"
+                      f"新增待连接 {added} 台"
+                      + (f"，自动重连恢复 {len(back)} 台 {back}" if back else ""))
+        _last_scan = (now, len(open_ips), len(verified), added)
+        _last_error = ""
+        return True, {"found": len(open_ips), "verified": len(verified), "new": added}
+    except Exception as e:
+        _log.warning(f"发现扫描异常: {e}")
+        _last_error = str(e)[:200]
+        return False, {"error": _last_error}
+    finally:
+        _scanning = False
+        _scan_lock.release()
+
+
+def device_pool_list_configured():
+    """设备池已配置 serial（延迟 import 避免循环依赖）。"""
+    from core import device_pool
+    return device_pool.list_configured()
+
+
+# ================== 正式池断联设备：自动重连 ==================
+def _reconnect_offline(configured):
+    """对正式池中断联的网络设备逐个 adb 重连，返回恢复的 serial 列表。
+
+    只重连网络设备（IP:5555；USB 设备插着就在，无需 connect）。
+    幂等轻量：内部 adb 全局锁串行，失败静默（下轮扫描再试）。
+    """
+    online_now = _parse_adb_devices(_adb("devices"))
+    targets = [s for s in (configured or [])
+               if ":" in s and s not in online_now]
+    if not targets:
+        return []
+    for serial in targets:
+        adb_connect_light(serial)
+    online_after = _parse_adb_devices(_adb("devices"))
+    return [s for s in targets if s in online_after]
+
+
+def list_pool_offline():
+    """正式设备池中断联的设备（serial + 型号 + 备注名），面板展示用。
+
+    断联设备仍是正式池成员（不删除、不进 pending）——pending 是给未授权
+    新设备的；它们由扫描线程每轮自动重连，也可前端手动立即重连。
+    """
+    online = _parse_adb_devices(_adb("devices"))
+    with _ctx():
+        rows = [d.to_dict() for d in Device.query.filter_by(enabled=True)
+                .order_by(Device.serial).all()]
+    return [{"serial": r["serial"], "model": r.get("model") or "",
+             "name": r.get("name") or ""}
+            for r in rows if r["serial"] not in online]
+
+
+# ================== 定时扫描线程 ==================
+def _discovery_loop():
+    """定时扫描 daemon 线程。每轮重读配置（开关/周期即时生效）。
+
+    启动先 sleep 15s 避让 web_server 预连接线程（两者都抢 adb 全局锁）。
+    等待用 30s 切片（_stop_event.wait），关停/改周期 ≤30s 生效。
+    """
+    try:
+        _stop_event.wait(15)
+        while not _stop_event.is_set():
+            try:
+                settings = get_settings()
+                if settings["enabled"]:
+                    scan_once()
+            except Exception as e:
+                _log.warning(f"发现定时扫描异常: {e}")
+            wait_s = max(10, settings.get("interval", 60))
+            waited = 0
+            while waited < wait_s and not _stop_event.is_set():
+                _stop_event.wait(min(30, wait_s - waited))
+                waited += min(30, wait_s - waited)
+    except Exception:
+        pass
+
+
+def init_app(app):
+    """web_server 启动时调用：绑 app + 起定时扫描 daemon 线程。"""
+    global _app
+    _app = app
+    _stop_event.clear()
+    t = threading.Thread(target=_discovery_loop, name="device-discovery", daemon=True)
+    t.start()
+    _log.info("设备自动发现线程已启动（默认 60s 扫描一次）")
+
+
+def shutdown():
+    """优雅退出：置 stop_event，等待中的循环在切片边界退出。"""
+    _stop_event.set()
+
+
+# ================== 对外查询与确认 ==================
+def get_status():
+    """API 状态快照：配置 + 扫描状态 + 最近一轮结果 + 待连接数量。"""
+    settings = get_settings()
+    with _ctx():
+        pending = PendingDevice.query.count()
+    return {
+        "enabled": settings["enabled"],
+        "subnets": settings["subnets"],
+        "interval": settings["interval"],
+        "port": settings["port"],
+        "scanning": _scanning,
+        "last_scan": _last_scan[0] if _last_scan else "",
+        "last_result": ({"found": _last_scan[1], "verified": _last_scan[2],
+                         "new": _last_scan[3]} if _last_scan else None),
+        "last_error": _last_error,
+        "pending_count": pending,
+    }
+
+
+def list_pending():
+    """待连接列表：只返回当前在线的设备（离线候选不可确认，不展示）。
+
+    后端直接过滤（2026-09-04）：不依赖前端 JS 版本，任何客户端都拿不到
+    离线条目；设备恢复在线后扫描自动更新 last_seen 并重新出现在列表。
+    """
+    online = _parse_adb_devices(_adb("devices"))
+    with _ctx():
+        rows = [p.to_dict() for p in PendingDevice.query.order_by(
+            PendingDevice.first_seen.desc()).all()]
+    return [dict(r, online=True) for r in rows if r["serial"] in online]
+
+
+def confirm_pending(serial, name=""):
+    """确认连接：pending 行 → 正式设备池（add_device upsert）→ 删 pending。
+
+    返回 (ok, msg, is_new)。adb_connect + 采型号由 API 层后台线程做。
+    """
+    with _ctx():
+        row = PendingDevice.query.get(serial)
+        if not row:
+            return False, "设备不在待连接列表", False
+        from core import device_pool
+        is_new = device_pool.add_device(serial, name=name or "")
+        PendingDevice.query.filter_by(serial=serial).delete()
+        db.session.commit()
+    return True, "已加入设备池" + ("" if is_new else "（已存在，信息已更新）"), is_new
+
+
+def ignore_pending(serial):
+    """忽略：删除 pending 行（下轮扫描可能再次发现）。"""
+    with _ctx():
+        row = PendingDevice.query.get(serial)
+        if not row:
+            return False, "设备不在待连接列表"
+        PendingDevice.query.filter_by(serial=serial).delete()
+        db.session.commit()
+    return True, "已忽略"

core/models.py

@@ -238,6 +238,21 @@ class Device(db.Model):
         return f"<Device {self.serial}>"
 
 
+class PendingDevice(db.Model):
+    """自动发现待连接池：扫描验证通过的设备，等待用户确认后才入正式池。
+
+    与 Device 表的区别：只代表"被扫描到、可连接"，不参与任务调度。
+    """
+    serial = db.Column(db.String(120), primary_key=True)   # 如 192.168.20.5:5555
+    source = db.Column(db.String(20), default="")          # lan / tailscale
+    first_seen = db.Column(db.String(20), default="")      # 首次发现时间
+    last_seen = db.Column(db.String(20), default="")       # 最近一次扫描仍可见的时间
+
+    def to_dict(self):
+        return {"serial": self.serial, "source": self.source or "",
+                "first_seen": self.first_seen or "", "last_seen": self.last_seen or ""}
+
+
 # 版本化 schema 迁移：新增结构变更时在此追加 (版本号, 说明, SQL)
 # 版本号单调递增，只执行比当前 schema_version 新的迁移。
 SCHEMA_MIGRATIONS = [
@@ -252,6 +267,12 @@ SCHEMA_MIGRATIONS = [
      "created_at VARCHAR(20) DEFAULT '')"),
     (3, "设备池：device 表新增 model 列（型号，在线时自动采集）",
      "ALTER TABLE device ADD COLUMN model TEXT DEFAULT ''"),
+    (4, "自动发现：pending_device 待连接池表（扫描发现的设备，用户确认后才入正式池）",
+     "CREATE TABLE IF NOT EXISTS pending_device ("
+     "serial VARCHAR(120) PRIMARY KEY,"
+     "source VARCHAR(20) DEFAULT '',"
+     "first_seen VARCHAR(20) DEFAULT '',"
+     "last_seen VARCHAR(20) DEFAULT '')"),
 ]
 
 
@@ -284,7 +305,18 @@ def _migrate_schema():
             if version <= current:
                 continue
             if sql:
+                try:
                     db.session.execute(text(sql))
+                except Exception as e:
+                    # 幂等兜底：目标结构已存在也视为该迁移生效。典型场景——
+                    # create_all 已按当前模型把列/表直接建好（如 perms、device.model），
+                    # 而 schema_version 又因历史中断没记录，导致每次启动重复 ALTER 报错。
+                    # duplicate column name 说明列已存在=迁移目标已达成：回滚本次语句后
+                    # 仍记录版本号，一次启动即自愈；其它异常才中止本批迁移。
+                    if "duplicate column name" not in str(e).lower():
+                        raise
+                    db.session.rollback()
+                    _log.info(f"schema 迁移 {version} 目标已存在，跳过: {desc}")
             db.session.execute(
                 text("INSERT OR REPLACE INTO app_meta(key,value) VALUES('schema_version',:v)"),
                 {"v": str(version)})

core/ocr.py

@@ -69,11 +69,22 @@ def recognize(image):
 def find_on_screen(image, keyword):
     """在截图上查找包含 keyword 的文字。
 
-    返回 (found, center_xy, matched_text)；center_xy 为文字中心像素坐标（可点击），
-    未命中返回 (False, None, "")。
+    返回 (found, center_xy, matched_text)；center_xy 为**关键词**中心像素坐标
+    （可点击），未命中返回 (False, None, "")。
+
+    OCR 一行常含多段文字（如 "医值得推荐#苏州济世璞真…展开"），若直接点整块
+    中心会偏离关键词很远。命中块文本较长时，按关键词在文本中的位置比例估算 x
+    （块内文字近似等宽），y 取块中心——中文场景估算偏差小，点击能落准。
     """
     for r in recognize(image):
-        if keyword in r["text"]:
+        text = r["text"]
+        if keyword in text:
             b = r["box"]
-            return True, ((b[0] + b[2]) // 2, (b[1] + b[3]) // 2), r["text"]
+            if len(text) <= 12:   # 短文本：整块中心即关键词中心
+                return True, ((b[0] + b[2]) // 2, (b[1] + b[3]) // 2), text
+            idx = text.find(keyword)
+            ratio = (idx + len(keyword) / 2) / len(text)
+            cx = b[0] + int((b[2] - b[0]) * ratio)
+            cy = (b[1] + b[3]) // 2
+            return True, (cx, cy), text
     return False, None, ""

core/task_manager.py

@@ -154,12 +154,24 @@ class TaskJob:
         elif mode == "group":
             g = manager.groups.get(self.target.get("group_name"))
             serials = list(g.serials) if g else []
+            # 分组应引用设备池内设备：不在池内的（如手动填的旧 IP）不参与调度，
+            # 与 all/preempt 模式口径一致（2026-09-01）
+            try:
+                configured = set(device_pool.list_configured())
+                serials = [s for s in serials if s in configured]
+            except Exception:
+                pass
         else:
             # all：默认返回池内在线设备（单实例互斥由 _run_with_retry 的 _running 保证）；
             # 抢占模式返回全部在线设备（含运行中，执行时抢占）
             if self.params.get("preempt"):
                 try:
-                    return device_pool.list_online()
+                    # 抢占模式：只抢设备池内的在线设备——
+                    # list_online() 会包含待连接/未入池设备（如自动发现验证时连上的），
+                    # 它们不在设备池就不该被任务调度（2026-09-01 修复）
+                    online = set(device_pool.list_online())
+                    configured = set(device_pool.list_configured())
+                    return [s for s in device_pool.list_online() if s in configured]
                 except Exception:
                     return []
             try:
@@ -337,6 +349,11 @@ class TaskManager:
     def __init__(self, app=None):
         self.app = app  # Flask app，用于 db context
         self.scheduler = BackgroundScheduler(timezone="Asia/Shanghai")
+        if os.environ.get("DISABLE_SCHEDULER"):
+            # 测试/回归模式：不启动 cron 调度器，避免 test_client 加载任务后
+            # 按 cron 真的跑任务（干扰回归、占用设备）。add_job 仍可调用不报错。
+            _log.info("DISABLE_SCHEDULER=1：跳过 cron 调度器（测试/回归模式）")
+        else:
             self.scheduler.start()
         start_watchdog()  # 启动心跳看门狗
         self.groups = {}        # name -> DeviceGroup(内存业务对象)
@@ -587,14 +604,10 @@ class TaskManager:
         return _next_run_time(job.schedule)
 
     def run_job_now(self, job_id):
-        """立即执行任务（手动触发）。运行窗口外拒绝启动。"""
+        """立即执行任务（手动触发）。运行窗口只约束定时触发，手动执行不受限制。"""
         job = self.jobs.get(job_id)
         if not job:
             return {"ok": False, "error": "任务不存在"}
-        if not _in_run_window(job.schedule):
-            win = job.schedule.get("window") or {}
-            return {"ok": False,
-                    "error": f"当前不在运行窗口内（{win.get('start', '')}-{win.get('end', '')}），任务未启动"}
         # 在独立线程跑，不阻塞调用方
         t = threading.Thread(target=self._run_job, args=(job,), daemon=True)
         t.start()
@@ -636,6 +649,9 @@ class TaskManager:
         # 错峰启动：在各自线程内等待，分摊批量启动的连接/占用压力
         if start_delay > 0:
             time.sleep(start_delay)
+        # 被抢占的原任务 id（抢占结束后归还）——必须在循环外：
+        # 重试时若重置为 None，finally 归还逻辑会丢失信息，被抢占任务永不恢复
+        preempted_job = None
         try:
             for attempt in range(1, max_attempts + 1):
                 # 用户已请求停止 → 不再启动新 attempt
@@ -645,7 +661,6 @@ class TaskManager:
                         return
                 # 同一 serial 同时只能一个 worker；不同任务可配置抢占
                 preempt = False
-                preempted_job = None  # 被抢占的原任务 id（抢占结束后归还）
                 with self._lock:
                     if serial in self._running:
                         cur = self._running[serial]
@@ -658,6 +673,7 @@ class TaskManager:
                             _log.warning(f"{serial} 已有任务在跑，跳过 (job={job.name})")
                             return
                         preempt = True
+                        if not preempted_job:
                             preempted_job = cur.get("job_id")
                 if preempt:
                     # 抢占：锁外停止该设备上的其他任务（stop_device 内部拿同一把锁，
@@ -749,6 +765,10 @@ class TaskManager:
                 if j and j.enabled:
                     _log.info(f"{serial} 抢占任务 {job.name} 结束，归还设备给任务 {j.name}")
                     threading.Thread(target=self._run_job, args=(j,), daemon=True).start()
+                else:
+                    # 打日志便于排查：被抢占任务已删除/停用时不会归还，但要知道原因
+                    _log.info(f"{serial} 抢占任务 {job.name} 结束，"
+                              f"被抢占任务 {preempted_job} {'已停用，不归还' if j else '已不存在，不归还'}")
 
     # ---- 运行控制 ----
     def stop_device(self, serial):
@@ -878,4 +898,7 @@ class TaskManager:
         self.stop_all()
         self._fg_scanner.stop()
         stop_watchdog()
+        try:
             self.scheduler.shutdown(wait=False)
+        except Exception:
+            pass  # DISABLE_SCHEDULER 模式下 scheduler 未 start，shutdown 会抛异常

core/uiauto_helper.py

@@ -190,9 +190,14 @@ def _extract(root, out):
         desc = props.get("content-desc", "")
         cls = props.get("class", "")
         tag = cls.split(".")[-1] if cls else "*"
-        # 始终带同 class 兄弟序号（含 [1]），结构路径才精确无歧义
+        # 始终带同 class 兄弟序号（含 [1]），结构路径才精确无歧义；
+        # class 为空的层（tag=*）不参与结构路径，避免 //*[N] 前缀污染导致选择器定位到任意节点
+        if tag != "*":
             seg = f"{tag}[{tag_index}]"
             own_tag_path = f"{tag_path}/{seg}" if tag_path else seg
+        else:
+            seg = ""
+            own_tag_path = tag_path
 
         # ---- 推荐选择器：唯一属性 > 锚点祖先限定 > 全结构路径 ----
         if rid:
@@ -205,6 +210,13 @@ def _extract(root, out):
             val = f"{ctx}/{seg}"
             suggested = {"type": "xpath", "value": val}
             child_ctx = val
+        else:
+            if tag == "*":
+                # class 也为空的元素：结构路径 //*[N] 无意义（匹配到文档任意节点），
+                # 标记 invalid，前端提示不可选，避免回填垃圾选择器导致"点击不到"
+                suggested = {"type": "xpath", "value": "",
+                             "invalid": True,
+                             "reason": "该元素无可用属性（id/文本/class），无法生成可靠选择器"}
             else:
                 # 无唯一属性且无锚点祖先：用从根开始的结构路径（脆弱，标记 broad 让前端提示）
                 suggested = {"type": "xpath", "value": f"//{own_tag_path}", "broad": True}

doc/API.md

@@ -642,6 +642,19 @@ IP:5555 设备添加后立即尝试 adb connect，并后台采集型号（getpro
 
 `?serial=xxx` 指定设备；浏览器 `<img src>` 直接渲染，客户端断开自动停止。数据源 u2（atx-agent minicap，约 3-6 帧/秒）。
 
+### GET /api/screen/thumb
+
+大屏缩略图：单张 JPEG（360px 宽，质量 55）。**权限**：`devices`。
+
+`?serial=xxx` 指定设备。监控大屏按设备每 ~2.5s 轮询一帧（页面不可见时暂停）；
+一次性请求（非流），与任务并发安全（与任务截图同走 u2 minicap）。
+
+### GET /wall
+
+监控大屏页面（全屏深色控制室风格，登录后可访问）：设备卡片网格（缩略图/型号/
+状态/当前动作/进度）、顶部统计与时钟；状态每 5s 刷新、缩略图每 2.5s 轮询。
+20 台设备整体开销约 0.2 核 CPU + 100KB/s 带宽，普通电脑无压力。
+
 ### POST /api/screen/tap
 
 点击设备屏幕。**权限**：`devices`。

doc/ARCHITECTURE.md

@@ -10,8 +10,8 @@
 
 | 层 | 路径 | 职责 |
 |----|------|------|
-| 配置层 | `config.py` | 项目根配置：STF 地址、adb 路径、web 端口等基础设施。**不放任务参数** |
-| 核心层 | `core/` | 框架运行时：日志、STF 客户端、adb 操作、Worker 基类、任务管理器、u2 辅助、Action 基类 |
+| 配置层 | `config.py` | 项目根配置：adb 路径、web 端口、USB 远程 adb server 等基础设施。**不放任务参数** |
+| 核心层 | `core/` | 框架运行时：日志、设备池、adb 操作、Worker 基类、任务管理器、u2 辅助、Action 基类 |
 | 任务层 | `tasks/` | 每个 App 一个子包，自包含 `task.py` + `actions/`，互不依赖 |
 | 前端层 | `templates/admin/` | 单页应用（纯 HTML+CSS+JS，无框架） |
 | 数据层 | `data/` | SQLite 持久化 |
@@ -39,7 +39,7 @@
        │ JSON API                        │                   ┌─────────────────┐
        ▼                          ┌──────────────┐           │ 设备 adb        │
 ┌──────────────┐                  │  看门狗监控   │           │ (IP:5555 直连  │
-│  web_server  │                  └──────────────┘           │  / USB 远程)   │
+│  web/ 蓝图包  │                  └──────────────┘           │  / USB 远程)   │
 │  (Flask API) │                                            └─────────────────┘
 └──────────────┘
        │
@@ -137,7 +137,7 @@ run() 主循环（不要重写）：
 
 **并发控制**：同一 serial 同时只允许一个 worker，避免冲突。
 
-**状态缓存**：`get_status()` 带 5 秒缓存，STF 请求慢时不阻塞前端。
+**状态缓存**：`get_status()` 带 5 秒缓存，避免每次 /api/status 都查库/adb 阻塞前端。
 
 ### 3.4 前台 App 扫描器（`_ForegroundScanner`）
 
@@ -145,12 +145,11 @@ run() 主循环（不要重写）：
 
 | 设备状态 | 处理方式 | 是否打扰 |
 |---------|---------|---------|
-| worker 运行中 | 复用已有 ADB 连接查询 | 否 |
-| 自己占用无 worker | STF remoteConnect 隧道查询 | 否 |
-| 完全空闲 | 返回"空闲"（不 adb connect，避免 STF 误判离线） | 否 |
-| 他人占用 | 标记"(他人占用)" | 否 |
+| worker 运行中（IP:5555） | 复用已有 ADB 连接查询 | 否 |
+| worker 运行中（USB） | 经 220 远程 adb server 查询 | 否 |
+| 完全空闲 | 返回"空闲"（不主动 connect） | 否 |
 
-> **为什么不扫描空闲设备的前台 App**：STF provider 内部通过 IP:5555 维持 adb 连接。外部 adb connect/disconnect 会让 adb server 断开该 transport，连带 STF provider 的连接断开，STF 误判设备 offline 并触发重连。
+> **为什么不扫描空闲设备的前台 App**：IP:5555 的 adb transport 是共享的（历史与 STF provider 共用），外部 connect/disconnect 会扰动共享连接，遵守既有红线。
 
 ### 3.5 ADB 操作（`core/adb_helper.py`）
 
@@ -158,8 +157,8 @@ run() 主循环（不要重写）：
 
 **铁律：绝不 kill-server**：
 - `adb kill-server` 会断开所有设备的 adb transport
-- 导致 STF provider 对全部设备误判离线并触发重连
-- 影响所有运行中的任务
+- 全部设备连接被重建，影响所有运行中的任务
+- 同理绝不 disconnect IP:5555（共享 transport 红线，见 DEVELOPMENT.md）
 
 | 函数 | 说明 |
 |------|------|
@@ -191,9 +190,9 @@ SQLAlchemy 模型，存于 `data/users.db`：
 ### 权限模型
 
 - `User.perms` 存业务权限位 JSON 数组（`tasks`/`devices`/`apks`/`logs`），`is_admin=true` 拥有全部权限（`has_perm` 短路）
-- 后端统一用 `@perm_required(PERM_X)` / `@admin_required` 装饰器拦截（web_server.py），无权限返回 403；
-  查看类 GET 接口只要求登录；用户管理、维护接口（STF 重启 `/api/stf/restart`、adb 终端 `/api/adb/cmd`）强制 `admin_required`
-- adb 终端安全红线：拒绝 `kill-server` / `disconnect`（STF provider 共享 adb transport，断开会误判全设备离线）
+- 后端统一用 `@perm_required(PERM_X)` / `@admin_required` 装饰器拦截（web/auth.py），无权限返回 403；
+  查看类 GET 接口只要求登录；用户管理、adb 终端（`/api/adb/cmd`）强制 `admin_required`
+- adb 终端安全红线：拒绝 `kill-server` / `disconnect`（共享 adb transport）
 - 前端 `loadMe()` 拉取 `/api/me`，用 `data-perm` 属性隐藏无权限的 tab/按钮，行内按钮用 `_can(perm)` 判断
 - 安全兜底：**前端隐藏只是 UX，权限强制在后端**；新增路由时按"写操作必须带权限装饰器"的约定
 
@@ -201,10 +200,10 @@ SQLAlchemy 模型，存于 `data/users.db`：
 
 APK 上传/解析/批量安装。
 
-**设备连接策略（直连，绕过 STF）**：
+**设备连接策略（直连）**：
 - 直接 `adb connect serial`（serial 是 IP:5555）
-- 不经过 STF occupy/release，避免 STF release 触发 agent 清理卸载 app
-- 安装后不主动 disconnect（STF provider 共享该 adb transport）
+- 不经过占用/释放（单实例互斥由调度器内存锁保证）
+- 安装后不主动 disconnect（共享 adb transport 红线）
 
 **安装流程**：
 1. 上传 APK → 保存到 `data/apks/` → pyaxmlparser 解析包名/版本 → 入库
@@ -232,23 +231,24 @@ APK 上传/解析/批量安装。
 - 引擎懒加载单例 + 并发加锁（识别约 0.2-0.5s/次）
 - 返回坐标约定：像素、原点左上
 
-### 3.10 STF 设备管理（`core/stf_device_mgmt.py`）
+### 3.10 Web 层蓝图包（`web/`）
 
-工具页"STF 设备管理"：维护 220 上 OpenSTF 设备池。
+路由按功能域拆分（模块化开发底线，便于定位问题）：
 
-背景：220 的 adb 跑在 Docker 容器（`STF_ADB_CONTAINER`，默认 `adb`）里，设备池由
-`/mnt/data/openstf/connect_devices.sh`（`STF_SCRIPT_PATH`）的 `DEVICES` 数组维护，cron 每 5 分钟补连。
-
-| 函数 | 说明 |
+| 模块 | 职责 |
 |------|------|
-| `status()` | 脚本配置 IP + 220 adb 实际连接状态 |
-| `add_device(ip)` | 用 220 的 python3 精确改脚本 DEVICES 块 + `docker exec adb adb connect` |
-| `remove_device(ip)` | 脚本删条目 + `adb disconnect` |
+| `auth.py` | 登录/登出/CSRF/权限装饰器/页面路由（/、/wall） |
+| `monitor.py` | 状态/运行控制/设备操作/远程看屏（流+缩略图+触控） |
+| `tasks_api.py` | 任务计划/分组/自定义动作/元素抓取/步骤测试 |
+| `admin_api.py` | 用户管理/日志 |
+| `tools_api.py` | adb 终端/剪贴板注入/应用版本 |
+| `devices_api.py` | 设备池管理（增删停用/重连/型号采集） |
+| `apks_api.py` | 应用管理 |
+| `tailscale_api.py` | Tailscale 管理 |
+| `common.py` | 跨模块共享（合并设备列表/屏幕状态） |
+| `context.py` | 共享对象注入（mgr/apk_mgr/device_pool） |
 
-关键点：
-- 脚本编辑用 python3 行级增删（sed 处理多行数组易误伤）
-- `adb connect` 到不可达 IP 会挂 40s+，220 侧用 `timeout 15` 兜底，超时保留在脚本由 cron 重试
-- 断开的是 220（STF provider 侧）的 adb 连接，与本机任务直连的 adb 相互独立
+`web_server.py` 只保留：app 创建、数据库初始化、蓝图注册、uiautodev 生命周期、启动（193 行）。
 
 ---
 

doc/MCP.md

@@ -0,0 +1,147 @@
+# MCP 手机控制 Server（`mcp_server/`）
+
+多模态 AI（DeepSeek/Claude 等）通过 [MCP（Model Context Protocol）](https://modelcontextprotocol.io) 实时操作 Android 手机的统一出口。AI 控制台（`mcp_agent/`）与外部 MCP 客户端都经它控制设备池中的手机。
+
+> 本文档 = 使用手册（工具清单/用法）。架构与演进设计见 [MCP_DESIGN.md](MCP_DESIGN.md)。
+
+## 架构
+
+```
+AI 控制台 / 外部 MCP 客户端
+        │  Streamable HTTP
+        ▼
+MCP Server  (:8033, mcp_server/mcp_server.py)     ← 19 个 de_* 工具
+        │  平台 HTTP API（登录 + CSRF）
+        ▼
+auto_control 平台 (:18050)                        ← 设备池/任务/看屏
+        │  adb / uiautomator2 / uiautodev / OCR
+        ▼
+Android 设备（IP:5555）
+```
+
+- 轻量通道直连（adb monkey 开 App、u2 输入、本地 OCR）不绕平台，省时省 token
+- 坐标换算、UI 吸附、剪贴板注入等细节全部在 Server 层消化，模型只需给意图
+
+## 运行与配置
+
+服务跑在 220 的 `python-app` 容器内（`scripts/start.sh` 自动拉起，端口 8033）。
+生产访问方式：`http://192.168.20.220:8033/mcp`；本机调试 `python3 -m mcp_server.mcp_server`。
+
+| 环境变量 | 默认 | 说明 |
+|---|---|---|
+| `MCP_PLATFORM_URL` | `http://127.0.0.1:18050` | 平台地址（Agent 与平台同机时用本机） |
+| `MCP_PLATFORM_USER` / `MCP_PLATFORM_PASS` | `admin` / 空 | 平台登录账号 |
+| `MCP_ALLOW_WRITE` | `0` | **写门控**：=1 才允许点击/输入/开关 App 等写操作（只读工具不受限） |
+| `MCP_ALLOWED_SERIALS` | 空=不限 | 设备白名单（逗号分隔），非空时只允许列出的 serial |
+| `MCP_HTTP_HOST` / `MCP_HTTP_PORT` | `0.0.0.0` / `8033` | 监听地址 |
+| `MCP_SCREENSHOT_WIDTH` | `540` | 截图返回宽度上限（px），模型看到的图即该坐标系 |
+| `MCP_JPEG_QUALITY` | `70` | 截图 JPEG 质量 |
+| `MCP_AUDIT_FILE` | `/var/log/mcp/audit.log` | 审计日志（每次工具调用一行） |
+| `MCP_PLATFORM_TIMEOUT` | `30` | 平台请求超时（秒） |
+
+生产（220 容器）已设 `MCP_ALLOW_WRITE=1`；`MCP_ALLOWED_SERIALS` 未设（= 平台设备池内可操作）。
+
+## 坐标空间（重要约定）
+
+- `de_screenshot` 返回 ≤540px 宽的 JPEG（display 空间），并附 `native_size`（设备原生分辨率）
+- `de_tap` / `de_swipe` 的坐标一律使用 **de_screenshot 返回图像的坐标系**，Server 按比例换算为原生坐标
+- **先截图、后点击**：Server 需要最近一次截图才能建立坐标空间（未截图就点击会报「请先执行 de_screenshot」）
+- `de_tap` 带**自动吸附**：点击点若落在某个可点击元素内，实际会点该元素中心——坐标只需大致对准，偏十几像素也能点准；点空白处则按原坐标
+- 返回的 `snapped/label` 可核对吸附结果（snapped=true 表示已吸到元素，label 为该元素文案）
+
+## 工具清单（19 个）
+
+### 设备与状态
+
+| 工具 | 用途 |
+|---|---|
+| `de_list_devices` | 列出可控制设备：serial / 型号 / 在线 / 任务状态 / 前台 App。**开局第一步** |
+| `de_foreground_app(serial)` | 当前前台 App 包名（dumpsys，MIUI 焦点为空时自动兜底） |
+
+### 观察屏幕（感知）
+
+| 工具 | 用途 |
+|---|---|
+| `de_screenshot(serial)` | 截图并返回图像（≤540px JPEG）+ 尺寸 + 亮/熄屏状态。多模态模型直接看图 |
+| `de_ui_tree(serial, limit=150)` | 当前界面元素树（text/id/desc/class/bounds）。**可点击元素排前**；limit 1-300 控制条数防 token 膨胀。用于确认界面上有什么 |
+| `de_ocr(serial)` | OCR 识别当前屏幕文字（UI 树没有的图片/WebView 文字也能识别），返回 [{text, score}] |
+
+### 点击与滑动（操作）
+
+| 工具 | 用途 |
+|---|---|
+| `de_tap_text(serial, text)` | **按屏幕文字点击**（推荐）：给一个屏幕上可见的文字（子串匹配）即找到并点其中心。原生控件走 UI 树，WebView/图片文字自动 OCR 兜底。找不到返回明确错误 |
+| `de_tap_element(serial, by, value, index=1)` | 按元素点击：`by` = text / id / desc（精确）或 text_contains / desc_contains（模糊）。多命中用 index 取第几个 |
+| `de_tap(serial, x, y)` | 坐标点击（截图坐标系，自动吸附，见上）。**纯图形目标（视频画面/无文字图标）才用它** |
+| `de_swipe(serial, x1,y1,x2,y2, duration=0.2)` | 滑动（截图坐标系；长按=同点起止 + duration≥1） |
+| `de_press_key(serial, key)` | 按键：back / home / recent / menu / power / volume_up / volume_down / enter / delete / search / camera |
+
+### 输入与剪贴板
+
+| 工具 | 用途 |
+|---|---|
+| `de_type_text(serial, text)` | 向当前界面输入框输入文字（支持中文，直设 EditText 不依赖剪贴板/粘贴） |
+| `de_set_clipboard(serial, text)` | 写入设备剪贴板（ClipInject 通道注入 + 读回验证） |
+| `de_read_clipboard(serial)` | 读取设备当前剪贴板内容 |
+
+### App 管理（轻量 adb 直连，不建 u2 会话）
+
+| 工具 | 用途 |
+|---|---|
+| `de_open_app(serial, package)` | 打开 App（adb monkey 直启，无需知道 activity——最快的打开路径） |
+| `de_stop_app(serial, package)` | 强制停止 App（am force-stop） |
+| `de_list_apps(serial, keyword="")` | 列出第三方已装应用（pm list packages -3），keyword 可过滤（如 "douyin"） |
+| `de_sleep(serial)` | 熄屏（**运行中任务会中断，慎用**） |
+| `de_wake(serial)` | 亮屏并解锁（熄屏时先调它再截图） |
+
+### 平台联动
+
+| 工具 | 用途 |
+|---|---|
+| `de_list_tasks()` | 列出平台任务计划（名称/类型/启用/调度），了解已自动化的工作 |
+
+## 推荐使用模式（操作手机的正确姿势）
+
+1. **`de_list_devices`** 确认目标设备在线
+2. **`de_screenshot`** 看图理解当前界面（图像会在下一次模型回合送达）
+3. **点击定位优先级**（从高到低）：
+   - 目标有可见文字 → **`de_tap_text`**（一次调用完成「找到并点击」，最可靠）
+   - 文字有歧义/多候选 → `de_ui_tree` 确认后 `de_tap_element`（text_contains 模糊匹配）
+   - 纯图形目标 → `de_tap` 坐标（**无需精算**，Server 自动吸附到可点元素中心）
+4. 输入文字：先点中输入框（de_tap_text / de_tap），再 `de_type_text`
+5. 每次关键操作后 `de_screenshot` 验证：界面变化 = 成功；无变化 = 未命中，换 de_tap_text / de_tap_element 重新定位，**不要重复点同一坐标**
+6. 完成/失败时用中文总结：做了什么、当前状态、注意事项
+7. 效率约束：界面未变不重复截图/点同位置；连续 6 步无进展停止并总结
+
+## 安全与审计
+
+- **写门控**：`MCP_ALLOW_WRITE=0`（默认）时点击/输入/开关 App 全部拒绝，只读工具可用
+- **设备白名单**：`MCP_ALLOWED_SERIALS` 非空时限制可操作的 serial
+- **审计日志**：每次调用记录 `{ts, tool, serial, args, result}` 到 `MCP_AUDIT_FILE`（220 上 `/tmp/mcp_audit.log`）
+- 操作对象限定平台设备池；`adb kill-server` / `adb disconnect` 属项目红线，任何工具不触碰
+
+## 客户端接入示例
+
+```python
+import asyncio
+from fastmcp import Client
+
+async def main():
+    async with Client("http://192.168.20.220:8033/mcp", timeout=30) as c:
+        devs = await c.call_tool("de_list_devices", {})
+        serial = devs.data["data"][0]["serial"]          # 取第一台在线设备
+        shot = await c.call_tool("de_screenshot", {"serial": serial})
+        img = shot.data["data"]["image"]                 # base64 JPEG（多模态模型可直接看图）
+        await c.call_tool("de_tap_text", {"serial": serial, "text": "搜索"})
+
+asyncio.run(main())
+```
+
+## AI 控制台（内置 Agent）
+
+Web 端「AI 控制台」Tab 内建的 Agent（`mcp_agent/`，OpenAI 兼容协议：DeepSeek 等）也通过本 Server 的同一批工具跑任务：
+
+- 流式输出 + 每步 MCP 工具调用实时展示（含截图缩略）
+- 多轮会话记忆（同会话上下文保留，新建会话清空）
+- **自进化经验记忆**：一轮成功操作会被提炼成「配方」存入 `agent_experience` 表，下次相似任务自动注入参考（命中/写入均有 🧠 提示卡）
+- 模型与 API Key 在 AI 控制台右上角 ⚙ 配置，存平台 `app_meta`

doc/MCP_DESIGN.md

@@ -0,0 +1,244 @@
+# MCP 手机控制（Mobile Control MCP Server）设计文档
+
+> 分支：dev:mcp | 状态：设计稿 | 日期：2026-09-04
+
+## 1. 背景与目标
+
+平台（auto_control，生产 220:18050）已具备完整的手机远程控制与自动化能力：设备池管理、u2 控制（tap/swipe/key/输入/剪贴板）、minicap 看屏（截图/流）、uiautodev 元素树、RapidOCR、任务调度与动作编辑器。
+
+本设计的目标：**新增一个 MCP Server，把平台能力以 MCP 协议暴露给多模态 AI（Claude 等），使 AI 能像人一样"看到手机屏幕 → 理解 → 操作 → 再看到"地闭环控制手机**。
+
+核心判断：平台能力全部已有，MCP Server 是**薄封装层**——主要工作在：工具规格设计、多模态图像链路、认证与安全、部署。
+
+## 2. 术语
+
+| 术语 | 说明 |
+|---|---|
+| MCP | Model Context Protocol，模型上下文协议（客户端-服务器，工具调用） |
+| Tools | MCP 暴露的可调用能力（本设计按 L1/L2/L3 分层） |
+| serial | 设备标识，如 `192.168.20.66:5555`（设备池唯一主键） |
+| 平台 | 指 auto_control web 服务（18050）及其 core 层能力 |
+| 宿主 | MCP Server 运行进程/容器 |
+
+## 3. 总体架构
+
+```
+┌──────────────┐   MCP (Streamable HTTP / stdio)   ┌──────────────────┐
+│  多模态 AI    │ ────────────────────────────────▶ │   MCP Server     │
+│ Claude Desktop│   tools + image content block    │  （220 独立进程） │
+│ Claude Code  │ ◀──────────────────────────────── │  mcp/ 包         │
+└──────────────┘   截图图像 / JSON 结果             └────────┬─────────┘
+                                                            │ 内部调用
+                                                            ▼
+                                                 ┌──────────────────┐
+                                                 │ auto_control     │
+                                                 │ 18050 REST API   │
+                                                 │ （登录会话 token）│
+                                                 ├──────────────────┤
+                                                 │ core 层能力：     │
+                                                 │ u2 / minicap /   │
+                                                 │ uiautodev / OCR /│
+                                                 │ 任务调度 / 设备池 │
+                                                 └──────────────────┘
+```
+
+- **图像方向**：MCP 协议支持 `image` content block（base64），截图以此返回，多模态模型原生可读——这是"AI 看到手机"的关键链路。
+- **控制方向**：AI 返回结构化工具调用（tap/swipe/type…），MCP Server 转发平台执行。
+- **循环**：截图 → 模型视觉推理 → 工具调用 → 平台执行 → 截图验证。
+
+## 4. 平台现有能力复用清单
+
+| 平台能力 | 现有入口 | MCP 复用方式 |
+|---|---|---|
+| 设备列表/状态 | `GET /api/status`、`/api/devices/pool` | MCP server 内部 HTTP 调用（带会话） |
+| 截图 | `GET /api/screen/thumb?serial=`（单帧 JPEG） | 直接转发为 image block（亦可直连 core u2 screenshot） |
+| 看屏流 | `/api/screen/stream`（MJPEG） | M0-M2 不需要；M3 可选（视频理解场景） |
+| 点击 | `POST /api/screen/tap {serial,x,y}` | 封装 tool `tap` |
+| 滑动 | `POST /api/screen/swipe` | 封装 `swipe` |
+| 按键 | `POST /api/screen/key` | 封装 `press_key` |
+| 输入文字 | ClipInject 通道（core.clipboard_helper）+ u2 input | 封装 `type_text` |
+| 剪贴板 | `POST /api/tools/clipboard/set`（ClipInject 通道） | 封装 `set_clipboard` |
+| 元素树 | `GET /api/uiauto/...`（uiautodev） | 封装 `get_ui_tree` |
+| OCR | core.ocr（RapidOCR） | 封装 `ocr_screen` |
+| 打开 App | u2 `app_start`（经任务层/直连） | 封装 `open_app`（走 core device 直连） |
+| 设备在线状态/亮熄屏 | `/api/device/screen_all`、dumpsys | 封装 `screen_state`/`wake` |
+
+> 决策：MCP Server 优先走 **HTTP API**（薄封装，认证简单、与平台解耦、平台安全逻辑全复用）。对延迟敏感且 HTTP 无入口的能力（u2 直连截图/输入），经平台 core 模块进程内调用或新增少量只读端点，不绕过平台安全层。
+
+## 5. MCP Server 设计
+
+### 5.1 技术栈
+
+- 语言/运行时：Python 3.11（与平台一致）
+- 框架：**FastMCP**（`fastmcp`，官方 SDK 之上，装饰器式 tools，自带 Streamable HTTP/stdio 双传输）
+- 依赖：`fastmcp`、`httpx`、`Pillow`（图像处理）、`mcp[cli]`
+- 日志：logging → 平台同款格式（时间/级别/模块）
+
+### 5.2 进程与容器
+
+- 独立容器 `mcp-server`（220 docker-compose 追加），image `python:3.11-slim`
+- 挂载：无数据挂载（无状态，配置走环境变量）；网络 host 或独立端口（**候选：8033**，避免与 18050/18051 冲突）
+- 独立于 auto_control 重启，互不阻塞；MCP Server 崩溃不影响平台，平台不可用时 MCP tools 返回明确错误
+
+### 5.3 配置（环境变量）
+
+| 变量 | 默认 | 说明 |
+|---|---|---|
+| `MCP_PLATFORM_URL` | `http://127.0.0.1:18050` | 平台地址 |
+| `MCP_PLATFORM_USER` / `MCP_PLATFORM_PASS` | 空 | 平台登录账号（admin） |
+| `MCP_ALLOW_WRITE` | `0` | 写操作总开关（0=只读感知，1=可操作） |
+| `MCP_ALLOWED_SERIALS` | 空=全部 | 设备白名单（逗号分隔；为空时自动=设备池内设备） |
+| `MCP_HTTP_PORT` | `8033` | HTTP 传输端口 |
+| `MCP_SCREENSHOT_WIDTH` | `540` | 截图宽度（等比缩放，控图像 token 成本） |
+| `MCP_JPEG_QUALITY` | `70` | 截图 JPEG 质量 |
+| `MCP_AUDIT_FILE` | `/var/log/mcp/audit.log` | 审计日志路径 |
+
+## 6. Tools 规格
+
+命名空间 `de_`（device）前缀避免与常见工具冲突。全部工具对**未配置白名单/离线设备**返回明确错误，不做静默跳过。
+
+### L1 感知层
+
+#### `de_list_devices`
+- 描述：列出可控制设备及其状态（在线/任务/型号/前台 App）
+- 返回：`[{serial, model, online, task_job, worker_status, foreground_app, screen_state}]`
+- 错误：平台不可达 → `platform_unavailable`
+
+#### `de_screenshot(serial: str) -> image`
+- 描述：截取设备当前屏幕（JPEG），返回 image content block；同时返回 `width/height/serial` 元信息
+- 实现：平台 `/api/screen/thumb`（X-Screen-State 头复用判断亮熄屏）；失败（离线/超时）→ 明确错误
+- 图像规格：宽 ≤ `MCP_SCREENSHOT_WIDTH`（默认 540），质量 `MCP_JPEG_QUALITY`；**需保证图像方向正确**（设备可能横竖屏，含 EXIF 或由调用方按截图尺寸推断）
+- 限制：截图频率 ≥ 1s/次（防 AI 疯狂截图），可配置
+
+#### `de_ui_tree(serial: str) -> str`
+- 描述：获取当前界面元素树（扁平 JSON：resource-id/text/content-desc/class/bounds），供定位
+- 返回：文本 JSON（大树截断至 `MCP_UI_TREE_MAX` 字符，默认 20000，防 context 爆炸）
+- 空界面/无元素 → 明确错误
+
+#### `de_ocr(serial: str) -> str`
+- 描述：OCR 识别当前屏幕文字，返回 `[{text, score, box}]`
+- 场景：图片/画布/WebView 渲染文字（UI 树里没有的）
+
+#### `de_screen_state(serial: str) -> str`
+- 描述：亮屏/熄屏/未知
+
+### L2 操作层（受 `MCP_ALLOW_WRITE=1` 门控）
+
+#### `de_tap(serial, x: int, y: int)`
+- 坐标：设备**原生分辨率**像素（与截图 1:1 换算——调用方用截图尺寸按比例换算，server 不做猜测）
+
+#### `de_swipe(serial, x1,y1,x2,y2, duration: float=0.2)`
+
+#### `de_press_key(serial, key: str)`
+- key ∈ back/home/recent/menu/power/enter/delete…
+
+#### `de_type_text(serial, text: str, clear_first: bool=True)`
+- 实现：优先 ClipInject 通道（`core.clipboard_helper.inject_clipboard` 语义：写入剪贴板 + paste 到焦点输入框），失败回退 u2 input
+- 中文/emoji 全支持（ClipInject 实测通过）
+
+#### `de_set_clipboard(serial, text: str)`
+- 写入设备剪贴板（ClipInject am start 通道），读回验证
+
+#### `de_open_app(serial, package: str)`
+- 打开指定 App（u2 app_start）；`package` 需在已知清单或完全限定名
+
+#### `de_wake(serial)` / `de_sleep(serial)`
+
+### L3 语义层（M2 里程碑）
+
+#### `de_find_and_tap(serial, target: str, by: "text"|"id"|"ocr"|"desc"=...)`
+- UI 树/OCR 定位含 target 的元素 → 自动点击其中心；多命中返回候选列表让 AI 选择
+- 复用平台元素选择器策略（属性唯一/重复序号消歧）
+
+#### `de_wait_until(serial, condition: str, timeout: int=15)`
+- 轮询 OCR/UI 树直到出现条件文本（或消失），返回命中的坐标/文本
+
+#### `de_get_task_state(serial)`（若二期接任务系统）
+- 设备当前任务状态；可选 `de_run_task(task_id)` 需单独授权
+
+### 工具返回约定
+- 全部工具返回结构化 JSON：`{ok: true, data: ...}` 或 `{ok: false, error: {code, message}}`
+- 错误码：`platform_unavailable` / `device_offline` / `device_not_allowed` / `invalid_param` / `write_disabled` / `busy`（设备被任务占用）
+- image 返回：`{ok:true, image: <content block>, width, height}`
+
+## 7. 图像链路细节
+
+1. 平台截图（`/api/screen/thumb`）→ JPEG 字节
+2. MCP Server 校验尺寸 → 等比缩放到 `MCP_SCREENSHOT_WIDTH`（用 Pillow，不重压缩已够质量则跳过）
+3. 组装 MCP `image` content block（`{"type":"image","data":<base64>,"mimeType":"image/jpeg"}`）
+4. 客户端（Claude）原生把 image 传入视觉上下文
+
+性能预算：540px JPEG ~40-80KB/张；模型一次多步操作 5-15 张 ≈ 1MB 以内，可接受。
+
+## 8. 认证与安全
+
+1. **平台会话**：MCP Server 启动时用 `MCP_PLATFORM_USER/PASS` 登录平台拿会话（Cookie），会话失效自动重登；不向客户端暴露平台凭据
+2. **写操作门控**：`MCP_ALLOW_WRITE=0`（默认）时 L2/L3 操作全部拒绝（`write_disabled`）——先部署只读，验证感知链路后再开写
+3. **设备白名单**：`MCP_ALLOWED_SERIALS` 指定；为空时自动限制为**设备池 enabled 设备**（平台口径）
+4. **占用互斥**：操作前查设备 `worker_status`——running/connecting 中拒绝操作（`busy`），避免 MCP 与任务打架
+5. **审计**：每次调用（含只读）写审计日志：`ts|tool|serial|args摘要|result`；落盘 `MCP_AUDIT_FILE`
+6. **传输安全**：内网部署（host 网络 8033）默认无 TLS；若外网暴露需前置 TLS/网络隔离（平台红线：设备控制接口不进公网）
+7. **无状态**：MCP Server 不存设备数据，全量透传平台
+
+## 9. 部署（220 docker-compose 追加）
+
+```yaml
+  mcp-server:
+    container_name: mcp-server
+    image: dockerproxy.net/library/python:3.11-slim
+    restart: unless-stopped
+    working_dir: /app
+    volumes:
+      - "./mcp_server:/app"
+    command: sh -c "pip install --no-cache-dir -i https://pypi.tuna.tsinghua.edu.cn/simple -r requirements.txt && python -m mcp_server"
+    environment:
+      - MCP_PLATFORM_URL=http://127.0.0.1:18050
+      - MCP_PLATFORM_USER=admin
+      - MCP_PLATFORM_PASS=${MCP_PLATFORM_PASS}   # .env 提供
+      - MCP_ALLOW_WRITE=1
+      - MCP_ALLOWED_SERIALS=
+    network_mode: host
+```
+
+客户端接入（Claude Code / Desktop）：
+
+```json
+// .mcp.json / claude_desktop_config.json
+{ "mcpServers": { "mobile": {
+    "url": "http://192.168.20.220:8033/mcp",
+    "transport": "streamable-http"
+}}}
+```
+
+## 10. 里程碑与验收
+
+| 里程碑 | 内容 | 验收标准 |
+|---|---|---|
+| M0 | Server 骨架 + `de_list_devices` + `de_screenshot` + `de_tap`/`de_swipe`（HTTP 传输、登录会话、审计骨架） | Claude Code 连上后：能列设备、截图（AI 能描述屏幕内容）、点击指定坐标生效 |
+| M1 | L1 完备（ui_tree/ocr/screen_state）+ L2 全量（key/type/clipboard/open_app/wake） | AI 完成「打开抖音搜索『奚学东』」多步操作 |
+| M2 | L3 语义层（find_and_tap/wait_until）+ 图像尺寸/性能调优 | AI 用自然语言指令（含中文输入）完成跨 3 步以上操作且自适应页面变化 |
+| M3 | 生产化：安全加固复核、审计看板、部署脚本、接入文档、任务系统互斥回归 | 日常稳定使用 1 周无异常 |
+
+## 11. 风险与开放问题
+
+1. **AI 误操作**：模型点击错位/误触关键按钮（如删除）——缓解：L3 定位优先于裸坐标、写门控先行、审计可追溯；**不做**二次确认（破坏自动化体验），靠白名单+占用互斥兜底
+2. **截图成本**：长会话多截图 → token/延迟成本——缓解：尺寸/质量可调、截图上限、`de_ui_tree` 作为低成本替代（文本树比图像便宜）
+3. **横竖屏/分辨率异构**：设备多样 → 坐标换算依赖截图 1:1；`de_find_and_tap`（语义层）不受分辨率影响
+4. **图像 content block 兼容性**：Claude 系原生支持；其他多模态客户端需验证（M0 用 Claude Code 验证）
+5. **是否接任务系统**：二期决策——`de_run_task` 语义与"单设备操作"不同（任务面向多设备调度），倾向二期用独立命名空间
+6. **clipboard/input 通道差异**：个别 MIUI 需授权 ClipInject——M0 阶段在受控设备集验证，必要时 fallback 链已在 core 层
+
+## 12. 附录：平台 API 映射（MCP → 平台）
+
+| MCP tool | 平台调用 |
+|---|---|
+| de_screenshot | GET /api/screen/thumb?serial= |
+| de_tap / de_swipe / de_press_key | POST /api/screen/tap|swipe|key |
+| de_type_text / de_set_clipboard | POST /api/tools/clipboard/set（ClipInject）+ u2 input |
+| de_ui_tree | GET /api/uiauto/…（或 core 直连） |
+| de_ocr | core.ocr（进程内或新只读端点） |
+| de_list_devices | GET /api/status + /api/devices/pool |
+| de_open_app | core device app_start（或任务层 open_app 动作） |
+| de_screen_state | dumpsys（core.common._device_screen_state） |
+
+> 实现时对平台缺失的只读入口（如 ocr/open_app 的直连面）优先在平台加**只读端点**（复用现有权限体系），MCP 不越权直连设备。

mcp_agent/__init__.py

@@ -0,0 +1 @@
+"""Agent 编排层：第三方 LLM（OpenAI 兼容）经 MCP 工具控制手机。"""

mcp_agent/agent.py

@@ -0,0 +1,291 @@
+"""Agent 编排层：OpenAI 兼容模型（DeepSeek 等）经 MCP 工具控制手机。
+
+支持两种运行模式：
+  - run_stream()：流式（SSE 逐 token + 工具调用实时回调）——Web AI 控制台用
+  - run()：非流式收集结果——CLI 用（内部调 run_stream）
+
+流式细节（OpenAI 兼容）：
+  - content/reasoning_content 增量逐 chunk 回调（kind 区分）
+  - tool_calls 分片累积（arguments 按 index 拼接），流结束后统一执行
+  - 截图（de_screenshot）图像转 image_url 追加下一轮，同时 on_tool 回调带缩略
+"""
+import base64
+import json
+import logging
+
+import httpx
+from fastmcp import Client
+
+from mcp_agent.config import AgentSettings
+
+_log = logging.getLogger("agent")
+
+S = AgentSettings()
+
+SYSTEM_PROMPT = """你是手机自动化控制助手。你通过工具实时操作 Android 手机。
+
+工作规范：
+1. 先 de_list_devices 确定目标设备（在线才可操作）
+2. 观察屏幕：先 de_screenshot 获取截图（图像会随后给你），基于截图理解当前界面
+3. 点击定位分优先级（不要自己推算像素坐标，那是精度最差的方式）：
+   a) 目标有可见文字（按钮/菜单/列表标题/标签/输入框提示）→ de_tap_text 直接给文字，
+      一次完成「找到并点击」，原生控件与 WebView/图片渲染文字都支持
+   b) 文字有歧义或 de_tap_text 未命中 → de_ui_tree(limit=80) 看可点元素后
+      用 de_tap_element（text/text_contains 匹配）
+   c) 只有纯图形目标（视频画面/无文字图标且树里没有）才用 de_tap 给坐标——
+      坐标只需大致对准目标中心，服务端会自动吸附到该处可点击元素中心，无需精算
+4. de_tap 点击后若返回 snapped=true 表示已吸附命中元素（可核对 label）；
+   截图判断界面变化=点击成功，无变化=未命中
+5. 输入文字：先 de_tap_text 或 de_tap 点中输入框，再 de_type_text 输入
+6. 每次关键操作后再次 de_screenshot 验证结果，直到完成用户目标
+7. 若点击后截图无任何变化：不要重复点同一坐标，换 de_tap_text/de_tap_element
+   重新定位，或先 de_ui_tree 确认元素文案再试
+8. 完成或失败时用中文总结：做了什么、当前状态、需要用户注意的事项
+9. 设备不可用/操作失败时如实报告错误，不要臆测成功
+10. 效率：界面未变化时不要重复截图/点击同一位置；每步都要推进目标；
+    若连续 6 步无进展（截图内容未变/操作无效），停止并总结原因，不要空转
+
+可用工具清单将由系统提供。"""
+
+
+class Agent:
+    def __init__(self, settings: AgentSettings = None):
+        self.s = settings or S
+        self.tools_schema = []      # OpenAI function schema
+        self.messages = []
+        # 回调（Web 展示用，均可选）：
+        #   on_delta(text, kind)  kind: content | reasoning   —— 流式文本增量
+        #   on_tool(step)         step: {tool, args, result, image} —— 工具调用完成
+        self.on_delta = None
+        self.on_tool = None
+        self._mcp = None
+
+    # ---------- MCP 工具桥 ----------
+    async def _load_tools(self):
+        """从 MCP Server 拉工具，转 OpenAI function schema。"""
+        # 短连接超时：MCP 不可用时快速失败（默认会无限重试卡死线程）
+        self._mcp = Client(self.s.mcp_url, timeout=10.0, init_timeout=10.0)
+        await self._mcp.__aenter__()
+        tools = await self._mcp.list_tools()
+        self.tools_schema = []
+        for t in tools:
+            # MCP SDK v2 改名 input_schema，兼容新旧字段
+            schema = getattr(t, "input_schema", None) or getattr(t, "inputSchema", {})
+            name = getattr(t, "name", "")
+            desc = getattr(t, "description", "") or ""
+            self.tools_schema.append({
+                "type": "function",
+                "function": {"name": name, "description": desc,
+                             "parameters": schema}})
+        _log.info("MCP 工具已加载: %s", [s["function"]["name"] for s in self.tools_schema])
+
+    async def close(self):
+        if self._mcp:
+            try:
+                await self._mcp.__aexit__(None, None, None)
+            except Exception:
+                pass
+
+    # ---------- 模型调用（流式） ----------
+    async def _chat_stream(self):
+        """流式 chat/completions：逐 chunk 产出 JSON（async generator）。"""
+        body = {
+            "model": self.s.model,
+            "messages": self.messages,
+            "tools": self.tools_schema if self.tools_schema else None,
+            "max_tokens": 4096,
+            "stream": True,
+        }
+        headers = {"Authorization": f"Bearer {self.s.api_key}",
+                   "Content-Type": "application/json"}
+        url = f"{self.s.api_base.rstrip('/')}/chat/completions"
+        async with httpx.AsyncClient(timeout=self.s.request_timeout) as client:
+            async with client.stream("POST", url, json=body, headers=headers) as r:
+                if r.status_code != 200:
+                    text = (await r.aread()).decode(errors="replace")
+                    raise RuntimeError(f"模型 API HTTP {r.status_code}: {text[:300]}")
+                async for line in r.aiter_lines():
+                    if not line.startswith("data:"):
+                        continue
+                    data = line[5:].strip()
+                    if data == "[DONE]":
+                        break
+                    try:
+                        yield json.loads(data)
+                    except json.JSONDecodeError:
+                        continue
+
+    # ---------- 工具执行 ----------
+    async def _execute_tool(self, name, arguments):
+        """执行 MCP 工具，返回 (文本结果, image_data_or_None)。"""
+        args = json.loads(arguments) if isinstance(arguments, str) else (arguments or {})
+        _log.info("执行工具 %s %s", name, args)
+        try:
+            result = await self._mcp.call_tool(name, args)
+            data = getattr(result, "data", result)
+        except Exception as e:
+            return {"ok": False, "error": f"工具执行失败: {e}"}, None
+        # de_screenshot：图像分离（作为 image_url 追加给模型看 + on_tool 缩略展示）
+        image_b64 = None
+        text_result = data
+        if name == "de_screenshot" and isinstance(data, dict) and data.get("ok"):
+            img = (data.get("data") or {}).get("image") or {}
+            if img.get("data"):
+                text_result = {k: v for k, v in (data.get("data") or {}).items()
+                               if k != "image"}
+                image_b64 = img["data"]
+        if self.on_tool:
+            try:
+                self.on_tool({"tool": name, "args": args,
+                              "result": text_result, "image": image_b64})
+            except Exception:
+                pass
+        return text_result, image_b64
+
+    def _repair_tool_messages(self):
+        """修复 tool_calls 配对不完整：从尾部移除「assistant 带 tool_calls 但其后
+        tool 回应不足」的消息段（流中断可能丢失分片，400 重试前自愈）。"""
+        for i in range(len(self.messages) - 1, -1, -1):
+            m = self.messages[i]
+            if m.get("role") == "assistant" and m.get("tool_calls"):
+                # 统计其后 tool 消息数是否匹配
+                need = len(m["tool_calls"])
+                have = sum(1 for x in self.messages[i + 1:]
+                           if x.get("role") == "tool")
+                if have < need:
+                    _log.warning("修复不完整 tool_calls 段（need=%d have=%d），回退 %d 条消息",
+                                 need, have, len(self.messages) - i)
+                    self.messages = self.messages[:i]
+                return
+
+    # ---------- 主循环（流式） ----------
+    async def run_stream(self, prompt: str, serial: str = "",
+                         history=None, on_delta=None, on_tool=None,
+                         should_stop=None, extra_context=None):
+        """流式执行一轮指令，返回最终完整文本。
+
+        history：上一轮的 [{"role": "user"|"assistant", "content": 文本}] 列表，
+        用于多轮对话保持上下文（截图/工具消息不入历史，控制 token）。
+        on_delta(text, kind)：content/reasoning 文本增量（实时推给前端）
+        on_tool(step)：工具调用完成（实时显示 MCP 步骤）
+        should_stop：可调用 fn() -> bool，每轮模型调用前检查（用户中断用）
+        extra_context：附加文本（经验记忆注入，放在 system prompt 末尾）
+        """
+        self.on_delta = on_delta
+        self.on_tool = on_tool
+        target = serial or self.s.default_serial
+        sys_txt = SYSTEM_PROMPT
+        if target:
+            sys_txt += f"\n\n本次默认目标设备 serial：{target}（未指定设备时用它）。"
+        if extra_context:
+            sys_txt += f"\n\n## 过往成功经验参考（同类任务，可参考其中的操作套路，但要根据当前界面灵活调整）\n{extra_context}"
+        self.messages = [{"role": "system", "content": sys_txt}]
+        for h in (history or []):
+            if h.get("role") in ("user", "assistant") and h.get("content"):
+                self.messages.append({"role": h["role"], "content": h["content"]})
+        self.messages.append({"role": "user", "content": prompt})
+
+        for _step in range(self.s.max_steps):
+            if should_stop and should_stop():
+                _log.info("Agent 被用户中断")
+                return "（已按用户要求停止操作）"
+            content_parts = []
+            tool_acc = {}           # index -> {id, name, args}
+            has_tool = False
+            retried = False
+            while True:
+                try:
+                    async for chunk in self._chat_stream():
+                        choice = (chunk.get("choices") or [{}])[0]
+                        delta = choice.get("delta") or {}
+                        text = delta.get("content")
+                        if text:
+                            content_parts.append(text)
+                            if on_delta:
+                                on_delta(text, "content")
+                        rtext = delta.get("reasoning_content")
+                        if rtext:
+                            if on_delta:
+                                on_delta(rtext, "reasoning")
+                        for tc in delta.get("tool_calls") or []:
+                            has_tool = True
+                            idx = tc.get("index", 0)
+                            acc = tool_acc.setdefault(idx, {"id": "", "name": "", "args": ""})
+                            if tc.get("id"):
+                                acc["id"] = tc["id"]
+                            fn = tc.get("function") or {}
+                            if fn.get("name"):
+                                acc["name"] += fn["name"]
+                            if fn.get("arguments"):
+                                acc["args"] += fn["arguments"]
+                    break
+                except RuntimeError as e:
+                    # 流中断导致 tool_calls 分片丢失：修复后重试一次
+                    if ("tool_calls" in str(e) or "must be followed" in str(e)) and not retried:
+                        _log.warning("tool_calls 消息不完整，自愈重试")
+                        self._repair_tool_messages()
+                        retried = True
+                        continue
+                    raise
+
+            full_content = "".join(content_parts)
+
+            if has_tool:
+                # 组装 assistant 消息（含 tool_calls）并执行工具
+                tcs = []
+                for idx in sorted(tool_acc):
+                    acc = tool_acc[idx]
+                    tcs.append({"id": acc["id"] or f"call_{idx}",
+                                "type": "function",
+                                "function": {"name": acc["name"],
+                                             "arguments": acc["args"]}})
+                self.messages.append({"role": "assistant",
+                                      "content": full_content,
+                                      "tool_calls": tcs})
+                for tc in tcs:
+                    fn = tc["function"]
+                    text_result, image_b64 = await self._execute_tool(
+                        fn["name"], fn["arguments"])
+                    self.messages.append({
+                        "role": "tool", "tool_call_id": tc["id"],
+                        "content": json.dumps(text_result, ensure_ascii=False)[:4000]})
+                    if image_b64:
+                        self.messages.append({
+                            "role": "user",
+                            "content": [{"type": "text",
+                                         "text": "这是最新屏幕截图，请基于它继续判断"},
+                                        {"type": "image_url",
+                                         "image_url": {"url":
+                                                       f"data:image/jpeg;base64,{image_b64}"}}]})
+                continue
+
+            # 无工具调用：本轮即最终回答
+            return full_content
+
+        # 步骤超限：不带工具让模型做最终总结（避免机械提示，给用户有意义的结论）
+        try:
+            _log.warning("达到最大步骤数，请求模型收尾总结")
+            saved_tools = self.tools_schema
+            self.tools_schema = []
+            self.messages.append({"role": "user",
+                                  "content": "已达最大操作步骤数，请立即用中文总结："
+                                             "已完成的部分、当前设备状态、未能完成的原因与下一步建议。"
+                                             "不要调用任何工具。"})
+            parts = []
+            async for chunk in self._chat_stream():
+                delta = (chunk.get("choices") or [{}])[0].get("delta") or {}
+                text = delta.get("content")
+                if text:
+                    parts.append(text)
+                    if on_delta:
+                        on_delta(text, "content")
+            self.tools_schema = saved_tools
+            summary = "".join(parts)
+            return summary or "（已达步骤上限，模型未能生成总结）"
+        except Exception as e:
+            return f"（已达最大步骤数，且收尾总结失败: {e}）"
+
+    # ---------- 非流式（CLI） ----------
+    async def run(self, prompt: str, serial: str = "") -> str:
+        """非流式执行，返回最终文本（CLI 用，内部走流式收集）。"""
+        return await self.run_stream(prompt, serial)

mcp_agent/cli.py

@@ -0,0 +1,60 @@
+"""Agent CLI：命令行给 AI 下指令控制手机。
+
+用法：
+    export AGENT_API_KEY=sk-xxx            # DeepSeek API Key
+    export AGENT_DEFAULT_SERIAL=192.168.20.66:5555   # 可选：默认设备
+    python -m mcp_agent.cli "打开抖音，搜索奚学东，截个图"
+    python -m mcp_agent.cli -s 192.168.20.66:5555 "打开微信"
+    python -m mcp_agent.cli                 # 交互模式（exit 退出）
+"""
+import argparse
+import asyncio
+import logging
+import os
+
+from mcp_agent.agent import Agent
+
+logging.basicConfig(level=logging.INFO,
+                    format="%(asctime)s %(levelname)s [%(name)s] %(message)s")
+_log = logging.getLogger("cli")
+
+
+async def _run_once(prompt, serial):
+    if not os.environ.get("AGENT_API_KEY") and not os.environ.get("DEEPSEEK_API_KEY"):
+        print("❌ 未配置 API Key：export AGENT_API_KEY=sk-xxx")
+        return
+    agent = Agent()
+    try:
+        await agent._load_tools()
+        print(f"🤖 指令: {prompt}\n")
+        answer = await agent.run(prompt, serial)
+        print(f"\n✅ 结果:\n{answer}")
+    finally:
+        await agent.close()
+
+
+def main():
+    ap = argparse.ArgumentParser(description="MCP 手机控制 Agent CLI")
+    ap.add_argument("prompt", nargs="?", default="", help="指令（不填则交互模式）")
+    ap.add_argument("-s", "--serial", default="", help="目标设备 serial")
+    args = ap.parse_args()
+
+    if args.prompt:
+        asyncio.run(_run_once(args.prompt, args.serial))
+        return
+
+    print("交互模式：输入指令（如「打开抖音搜索奚学东」），exit 退出")
+    while True:
+        try:
+            prompt = input("\n指令> ").strip()
+        except (EOFError, KeyboardInterrupt):
+            break
+        if not prompt:
+            continue
+        if prompt.lower() in ("exit", "quit", "退出"):
+            break
+        asyncio.run(_run_once(prompt, args.serial))
+
+
+if __name__ == "__main__":
+    main()

mcp_agent/config.py

@@ -0,0 +1,30 @@
+"""Agent 层配置（第三方 LLM API，OpenAI 兼容格式）。
+
+DeepSeek 官方 API：https://api.deepseek.com（OpenAI 兼容）。
+生产用 .env 注入 DEEPSEEK_API_KEY，不要提交 git。
+"""
+import os
+
+
+def _env(key, default):
+    return os.environ.get(key, default)
+
+
+class AgentSettings:
+    # 模型 API（OpenAI 兼容）
+    api_base = _env("AGENT_API_BASE", "https://api.deepseek.com")
+    api_key = _env("AGENT_API_KEY", _env("DEEPSEEK_API_KEY", ""))
+    model = _env("AGENT_MODEL", "deepseek-v4-flash-vision-exp")
+
+    # MCP Server（工具源）
+    mcp_url = _env("AGENT_MCP_URL", "http://127.0.0.1:8033/mcp")
+
+    # 默认目标设备（命令行不指定 serial 时用它；空则让模型先 de_list_devices）
+    default_serial = _env("AGENT_DEFAULT_SERIAL", "")
+
+    # Agent 循环上限与请求超时
+    max_steps = int(_env("AGENT_MAX_STEPS", "40"))
+    request_timeout = float(_env("AGENT_TIMEOUT", "120"))
+
+    # system prompt 语言
+    language = _env("AGENT_LANG", "zh")

mcp_server/__init__.py

@@ -0,0 +1 @@
+"""MCP 手机控制 Server 包。"""

mcp_server/audit.py

@@ -0,0 +1,27 @@
+"""审计日志：每次 MCP 调用记录一行（含只读）。"""
+import json
+import os
+from datetime import datetime
+
+_file = None
+
+
+def init(path):
+    global _file
+    os.makedirs(os.path.dirname(path), exist_ok=True)
+    _file = open(path, "a", encoding="utf-8")
+    audit("system", "startup", "", "")
+
+
+def audit(tool, serial, args_summary, result):
+    global _file
+    if _file is None:
+        return
+    rec = {"ts": datetime.now().isoformat(timespec="seconds"),
+           "tool": tool, "serial": serial,
+           "args": str(args_summary)[:200], "result": str(result)[:200]}
+    try:
+        _file.write(json.dumps(rec, ensure_ascii=False) + "\n")
+        _file.flush()
+    except Exception:
+        pass

mcp_server/config.py

@@ -0,0 +1,32 @@
+"""MCP Server 配置（环境变量，生产用 .env 注入）。"""
+import os
+
+
+def _env(key, default):
+    return os.environ.get(key, default)
+
+
+class Settings:
+    # 平台（auto_control）地址与账号
+    platform_url = _env("MCP_PLATFORM_URL", "http://127.0.0.1:18050")
+    platform_user = _env("MCP_PLATFORM_USER", "admin")
+    platform_pass = _env("MCP_PLATFORM_PASS", "")
+
+    # 安全
+    allow_write = _env("MCP_ALLOW_WRITE", "0") == "1"   # 写操作门控（默认只读）
+    allowed_serials = [s.strip() for s in
+                       _env("MCP_ALLOWED_SERIALS", "").split(",") if s.strip()]  # 空=不限
+
+    # 传输
+    http_host = _env("MCP_HTTP_HOST", "0.0.0.0")
+    http_port = int(_env("MCP_HTTP_PORT", "8033"))
+
+    # 截图
+    screenshot_width = int(_env("MCP_SCREENSHOT_WIDTH", "540"))
+    jpeg_quality = int(_env("MCP_JPEG_QUALITY", "70"))
+
+    # 审计
+    audit_file = _env("MCP_AUDIT_FILE", "/var/log/mcp/audit.log")
+
+    # 平台请求超时（秒）
+    platform_timeout = float(_env("MCP_PLATFORM_TIMEOUT", "30"))

mcp_server/direct_ops.py

@@ -0,0 +1,110 @@
+"""MCP 直连操作封装：adb/u2/OCR/剪贴板——轻量通道优先。
+
+为什么直连而不是全部走平台 HTTP：
+  - adb monkey 打开 App / am force-stop：一条 adb 命令，不建 u2 连接（省时省 token）
+  - 输入文字：u2 EditText.set_text 直接设文本（比剪贴板+粘贴少依赖）
+  - OCR：平台 RapidOCR（本地模型，截图即识别）
+平台 REST 无法表达的操作（无独立端点）在此封装；安全（白名单/写门控）
+仍在 MCP 工具层统一把关。绝不 kill-server / 绝不 disconnect（项目红线）。
+"""
+import re
+import subprocess
+
+from config import ADB_PATH
+
+_log = None  # mcp 层 logging 由调用方配置
+
+
+def _adb(serial, *args, timeout=25):
+    """对指定设备执行 adb shell 命令，返回输出文本（超时返回空）。"""
+    try:
+        r = subprocess.run([ADB_PATH, "-s", serial, "shell", *args],
+                           capture_output=True, timeout=timeout)
+        return (r.stdout or b"").decode("utf-8", errors="replace")
+    except subprocess.TimeoutExpired:
+        return ""
+    except Exception:
+        return ""
+
+
+def open_app(serial, package):
+    """adb monkey 打开 App（无需知道 activity，最轻量）。"""
+    out = _adb(serial, "monkey", "-p", package,
+               "-c", "android.intent.category.LAUNCHER", "1")
+    return out or ""
+
+
+def stop_app(serial, package):
+    """强制停止 App（am force-stop）。"""
+    return _adb(serial, "am", "force-stop", package)
+
+
+def foreground_app(serial):
+    """当前前台 App 包名（dumpsys window；mCurrentFocus 为空时 fallback mFocusedApp）。"""
+    out = _adb(serial, "dumpsys", "window", timeout=15) or ""
+    m = re.search(r"mCurrentFocus=.*?([\w.]+)/", out)
+    if m:
+        return m.group(1)
+    # 部分 MIUI 焦点在 IME/过渡时 mCurrentFocus=null，用 mFocusedApp 兜底
+    m2 = re.search(r"mFocusedApp=.*?([\w.]+)/", out)
+    return m2.group(1) if m2 else ""
+
+
+def list_apps(serial, keyword=""):
+    """第三方已装应用包名列表（pm list packages -3，可关键词过滤）。"""
+    out = _adb(serial, "pm", "list", "packages", "-3")
+    pkgs = []
+    for line in (out or "").splitlines():
+        p = line.replace("package:", "").strip()
+        if p and (not keyword or keyword.lower() in p.lower()):
+            pkgs.append(p)
+    return pkgs
+
+
+def type_text(serial, text):
+    """向当前界面输入框输入文字（u2 定位 EditText set_text，支持中文）。
+
+    返回 (ok, msg)。
+    """
+    import uiautomator2 as u2
+    d = u2.connect(serial)
+    # 优先聚焦输入框；找不到则第一个 EditText（与任务 input_text 兜底一致）
+    try:
+        el = d(focused=True)
+        if el.exists:
+            el.set_text(text)
+            return True, "已输入到聚焦输入框"
+    except Exception:
+        pass
+    try:
+        edit = d(className="android.widget.EditText")
+        if edit.exists:
+            edit.set_text(text)
+            return True, "已输入到输入框"
+    except Exception as e:
+        return False, f"输入失败: {type(e).__name__}: {str(e)[:100]}"
+    return False, "未找到输入框（请先点击输入框或提供界面信息）"
+
+
+def set_clipboard(serial, text):
+    """剪贴板注入（ClipInject 通道，读回验证）。"""
+    from core.clipboard_helper import inject_clipboard
+    return inject_clipboard(serial, text)
+
+
+def ocr(serial):
+    """截屏 + RapidOCR 识别，返回 [{text, score, box}]。"""
+    import uiautomator2 as u2
+    from core.ocr import recognize
+    d = u2.connect(serial)
+    img = d.screenshot()
+    if img is None:
+        return []
+    return recognize(img)
+
+
+def read_clipboard(serial):
+    """读设备剪贴板（u2）。"""
+    import uiautomator2 as u2
+    d = u2.connect(serial)
+    return d.clipboard or ""

mcp_server/mcp_server.py

@@ -0,0 +1,520 @@
+"""MCP 手机控制 Server（M0：设备列表/截图/点击/滑动）。
+
+运行：MCP_ALLOW_WRITE=1 python -m mcp_server.mcp_server
+客户端：Streamable HTTP @ http://<host>:8033/mcp
+"""
+import base64
+import io
+import logging
+
+from fastmcp import FastMCP
+from PIL import Image
+
+from mcp_server import audit, config
+from mcp_server.platform_client import PlatformClient, PlatformError
+
+logging.basicConfig(level=logging.INFO,
+                    format="%(asctime)s %(levelname)s [%(name)s] %(message)s")
+_log = logging.getLogger("mcp")
+
+S = config.Settings()
+
+# 坐标空间缓存：serial -> (display_w, display_h, native_w, native_h)
+# de_screenshot 返回的图与 de_tap/de_swipe 的坐标同一空间（display），
+# server 按比例换算为设备原生坐标（模型只感知截图坐标系，不感知原生分辨率）。
+_coord = {}
+audit.init(S.audit_file)
+
+mcp = FastMCP("mobile-control")
+_platform = None
+
+
+def platform():
+    """惰性初始化平台客户端（启动即登录，失败明确报错）。"""
+    global _platform
+    if _platform is None:
+        _platform = PlatformClient(S.platform_url, S.platform_user,
+                                   S.platform_pass, S.platform_timeout)
+    return _platform
+
+
+def _check_serial(serial):
+    """白名单校验：未配置时限制为平台设备池（enabled）设备。"""
+    if not serial:
+        raise PlatformError("invalid_param", "缺少 serial")
+    if S.allowed_serials and serial not in S.allowed_serials:
+        raise PlatformError("device_not_allowed", f"设备 {serial} 不在白名单")
+    return serial
+
+
+def _check_write():
+    if not S.allow_write:
+        raise PlatformError("write_disabled", "写操作未启用（MCP_ALLOW_WRITE=1 开启）")
+
+
+# 设备任务占用锁：serial -> (ts, worker_status, task_job)。AI 写操作前检查，
+# 任务 running/connecting 的设备拒绝操作（AI 不与任务抢设备）。5s 缓存。
+_busy_cache = {}
+
+
+def _ensure_device_free(serial):
+    """写操作前检查设备是否有任务在跑（worker running/connecting → 拒绝）。"""
+    import time
+    now = time.time()
+    c = _busy_cache.get(serial)
+    if not c or now - c[0] > 5:
+        try:
+            devs = platform().list_devices()
+            info = next((d for d in devs if d.get("serial") == serial), {})
+            c = (now, info.get("worker_status") or "idle",
+                 info.get("task_job") or "")
+            _busy_cache[serial] = c
+        except Exception:
+            return  # 状态查询失败不阻塞（操作失败会另行报错）
+    if c[1] in ("running", "connecting"):
+        raise PlatformError(
+            "device_busy",
+            f"设备正在执行任务「{c[2] or '未知'}」——AI 不与任务抢设备，"
+            f"任务结束后才能操作（可在平台任务页先停止任务）")
+
+
+def _to_native(serial, x, y):
+    """截图坐标 → 设备原生坐标（按最近一次截图的比例换算）。"""
+    c = _coord.get(serial)
+    if not c:
+        raise PlatformError("invalid_param",
+                            "请先对该设备执行 de_screenshot（需要建立坐标空间）")
+    dw, dh, nw, nh = c
+    return (round(x * nw / dw), round(y * nh / dh))
+
+
+def _err(e: PlatformError):
+    return {"ok": False, "error": {"code": e.code, "message": e.message}}
+
+
+def _ok(data):
+    return {"ok": True, "data": data}
+
+
+@mcp.tool()
+def de_list_devices() -> dict:
+    """列出可控制设备：serial/在线状态/型号/任务状态/前台 App。
+
+    返回 [{serial, model, online, task_job, worker_status, foreground_app}]。
+    """
+    try:
+        devs = platform().list_devices()
+    except PlatformError as e:
+        return _err(e)
+    out = []
+    for d in devs:
+        out.append({
+            "serial": d.get("serial"),
+            "model": d.get("model") or d.get("device_name") or "",
+            "online": bool(d.get("present")),
+            "task_job": d.get("task_job") or "",
+            "worker_status": d.get("worker_status") or "idle",
+            "foreground_app": d.get("foreground_app") or "",
+        })
+    audit.audit("de_list_devices", "", "", f"{len(out)} 台")
+    return _ok(out)
+
+
+@mcp.tool()
+def de_screenshot(serial: str) -> dict:
+    """截取设备屏幕并返回图像（image/jpeg，宽 ≤540px）。
+
+    同时返回 {width, height, screen_state}。多模态客户端可直接看图。
+    """
+    try:
+        serial = _check_serial(serial)
+        jpeg, screen_state = platform().screenshot(serial)
+        img = Image.open(io.BytesIO(jpeg))
+        w, h = img.size
+        if w > S.screenshot_width:
+            ratio = S.screenshot_width / w
+            img = img.resize((S.screenshot_width, int(h * ratio)))
+        buf = io.BytesIO()
+        img.convert("RGB").save(buf, "JPEG", quality=S.jpeg_quality)
+        data = base64.b64encode(buf.getvalue()).decode()
+        # 记录坐标空间（display=返回图尺寸，native=设备原生），供 tap/swipe 换算
+        nw, nh = platform().screen_size(serial)
+        _coord[serial] = (img.size[0], img.size[1], nw, nh)
+    except PlatformError as e:
+        return _err(e)
+    except Exception as e:
+        return _err(PlatformError("platform_unavailable", f"截图处理失败: {e}"))
+    audit.audit("de_screenshot", serial, f"{w}x{h}", "ok")
+    dw, dh, nw, nh = _coord[serial]
+    return _ok({"image": {"type": "image", "data": data,
+                          "mimeType": "image/jpeg"},
+                "width": dw, "height": dh,
+                "native_size": {"width": nw, "height": nh},
+                "screen_state": screen_state})
+
+
+@mcp.tool()
+def de_tap(serial: str, x: int, y: int) -> dict:
+    """点击设备屏幕指定坐标（坐标空间 = de_screenshot 的图像坐标）。
+
+    自动吸附：若该点落在某个可点击元素内，实际点击会改为该元素的中心——
+    坐标只需大致对准目标即可（模型视觉定位常有偏差，吸附保证点准）；
+    点在空白处则按原坐标点击。返回中的 snapped/label 可核对吸附结果。
+    """
+    try:
+        _check_write()
+        serial = _check_serial(serial)
+        _ensure_device_free(serial)
+        if x < 0 or y < 0:
+            raise PlatformError("invalid_param", "坐标不能为负")
+        nx, ny = _to_native(serial, x, y)
+        res = platform().tap(serial, nx, ny, snap=True)
+    except PlatformError as e:
+        return _err(e)
+    audit.audit("de_tap", serial,
+                f"({x},{y})->native({nx},{ny})"
+                + (f" 吸附[{res.get('label')}]" if res.get("snapped") else ""),
+                "ok")
+    return _ok({"action": "tap", "serial": serial, "x": x, "y": y,
+                "snapped": bool(res.get("snapped")),
+                "label": res.get("label") or ""})
+
+
+@mcp.tool()
+def de_swipe(serial: str, x1: int, y1: int, x2: int, y2: int,
+             duration: float = 0.2) -> dict:
+    """在设备屏幕上滑动（坐标空间同 de_tap：截图坐标，server 换算原生）。"""
+    try:
+        _check_write()
+        serial = _check_serial(serial)
+        _ensure_device_free(serial)
+        nx1, ny1 = _to_native(serial, x1, y1)
+        nx2, ny2 = _to_native(serial, x2, y2)
+        platform().swipe(serial, nx1, ny1, nx2, ny2, duration)
+    except PlatformError as e:
+        return _err(e)
+    audit.audit("de_swipe", serial, f"({x1},{y1})->({x2},{y2})", "ok")
+    return _ok({"action": "swipe", "serial": serial})
+
+
+_KEYS = ("back", "home", "recent", "menu", "power", "volume_up",
+         "volume_down", "enter", "delete", "search", "camera")
+
+
+@mcp.tool()
+def de_ui_tree(serial: str, limit: int = 150) -> dict:
+    """获取当前界面元素树（文本 JSON）：每元素含 text/resource_id/description/class/bounds。
+
+    可点击元素排在前面（可点性优先）。多数场景不需要读整棵树——直接给
+    de_tap_text 一个屏幕上可见的文字即可自动定位点击；本工具用于确认界面
+    上有什么、元素文案是否与预想一致。limit 控制返回条数（默认 150，防 token 膨胀）。
+    """
+    try:
+        serial = _check_serial(serial)
+        if limit < 1 or limit > 300:
+            raise PlatformError("invalid_param", "limit 需在 1-300 之间")
+        els = platform().ui_elements(serial)
+    except PlatformError as e:
+        return _err(e)
+    # 精简输出：去掉 suggested/深度噪音，保留可定位属性；可点击优先、有文案优先
+    slim = []
+    for e in els:
+        slim.append({
+            "text": e.get("text", "")[:50],
+            "id": e.get("resource_id", "")[:80],
+            "desc": e.get("description", "")[:50],
+            "class": e.get("class", "").split(".")[-1],
+            "clickable": e.get("clickable", "") == "true",
+            "bounds": e.get("bounds", ""),
+        })
+    slim.sort(key=lambda x: (not x["clickable"], not (x["text"] or x["desc"])))
+    audit.audit("de_ui_tree", serial, "", f"{len(slim)} 元素")
+    return _ok({"count": len(slim), "elements": slim[:limit]})
+
+
+@mcp.tool()
+def de_tap_element(serial: str, by: str, value: str, index: int = 1) -> dict:
+    """按元素点击（不需要坐标）：by=text|id|desc|text_contains|desc_contains。
+
+    text/id/desc 为精确匹配；text_contains/desc_contains 为子串模糊匹配
+    （只记得部分文字时用，如 by=text_contains value=搜索）。
+    元素驱动操作比坐标可靠（界面变化自适应）；元素不存在时返回错误，
+    可改用 de_ui_tree 查元素 / de_tap_text 按屏幕文字点 / de_tap 坐标兜底。
+    index 用于多命中取第几个（默认 1）。
+    """
+    try:
+        _check_write()
+        serial = _check_serial(serial)
+        _ensure_device_free(serial)
+        if by not in ("text", "id", "desc", "text_contains", "desc_contains"):
+            raise PlatformError("invalid_param",
+                                "by 可选 text/id/desc/text_contains/desc_contains")
+        if not value or index < 1:
+            raise PlatformError("invalid_param", "value 不能为空且 index>=1")
+        import uiautomator2 as u2
+        d = u2.connect(serial)
+        kw = {"text": value} if by == "text" else (
+            {"resourceId": value} if by == "id" else (
+                {"description": value} if by == "desc" else (
+                    {"textContains": value} if by == "text_contains"
+                    else {"descriptionContains": value})))
+        if index > 1:
+            kw["instance"] = index - 1
+        el = d(**kw)
+        if not el.exists:
+            raise PlatformError("device_offline",
+                                f"未找到元素（{by}={value}，index={index}）——"
+                                f"建议 de_ui_tree 查看实际元素或 de_tap 用坐标")
+        el.click()
+    except PlatformError as e:
+        return _err(e)
+    except Exception as e:
+        return _err(PlatformError("platform_unavailable",
+                                  f"元素点击失败: {type(e).__name__}: {str(e)[:100]}"))
+    audit.audit("de_tap_element", serial, f"{by}={value}#{index}", "ok")
+    return _ok({"action": "tap_element", "serial": serial,
+                "by": by, "value": value, "index": index})
+
+
+@mcp.tool()
+def de_read_clipboard(serial: str) -> dict:
+    """读取设备当前剪贴板内容（ClipInject/atx-agent 通道读回，M1 起支持）。"""
+    try:
+        serial = _check_serial(serial)
+        import uiautomator2 as u2
+        d = u2.connect(serial)
+        text = d.clipboard
+    except PlatformError as e:
+        return _err(e)
+    except Exception as e:
+        return _err(PlatformError("platform_unavailable",
+                                  f"剪贴板读取失败: {type(e).__name__}: {str(e)[:100]}"))
+    audit.audit("de_read_clipboard", serial, "", f"{len(text or '')} 字符")
+    return _ok({"clipboard": text or ""})
+
+
+@mcp.tool()
+def de_wake(serial: str) -> dict:
+    """点亮设备屏幕并解锁（熄屏时先调用它再截图）。"""
+    try:
+        _check_write()
+        serial = _check_serial(serial)
+        _ensure_device_free(serial)
+        platform().wake(serial)
+    except PlatformError as e:
+        return _err(e)
+    audit.audit("de_wake", serial, "", "ok")
+    return _ok({"action": "wake", "serial": serial})
+
+
+@mcp.tool()
+def de_press_key(serial: str, key: str) -> dict:
+    """按设备按键：back/home/recent/menu/power/enter/delete 等。"""
+    try:
+        _check_write()
+        serial = _check_serial(serial)
+        _ensure_device_free(serial)
+        if key not in _KEYS:
+            raise PlatformError("invalid_param", f"不支持的按键: {key}（可选 {_KEYS}）")
+        platform().press_key(serial, key)
+    except PlatformError as e:
+        return _err(e)
+    audit.audit("de_press_key", serial, key, "ok")
+    return _ok({"action": "press_key", "serial": serial, "key": key})
+
+
+# ================== L2 扩展工具（轻量通道：adb/u2 直连，省 token） ==================
+@mcp.tool()
+def de_open_app(serial: str, package: str) -> dict:
+    """打开 App（adb monkey 直启，最快路径）。package 为应用包名，如 com.ss.android.ugc.aweme。"""
+    try:
+        _check_write()
+        serial = _check_serial(serial)
+        _ensure_device_free(serial)
+        if not package:
+            raise PlatformError("invalid_param", "缺少包名")
+        from mcp_server import direct_ops
+        direct_ops.open_app(serial, package)
+    except PlatformError as e:
+        return _err(e)
+    except Exception as e:
+        return _err(PlatformError("platform_unavailable", f"打开失败: {str(e)[:100]}"))
+    audit.audit("de_open_app", serial, package, "ok")
+    return _ok({"action": "open_app", "package": package})
+
+
+@mcp.tool()
+def de_stop_app(serial: str, package: str) -> dict:
+    """强制停止 App（am force-stop）。"""
+    try:
+        _check_write()
+        serial = _check_serial(serial)
+        _ensure_device_free(serial)
+        if not package:
+            raise PlatformError("invalid_param", "缺少包名")
+        from mcp_server import direct_ops
+        direct_ops.stop_app(serial, package)
+    except PlatformError as e:
+        return _err(e)
+    except Exception as e:
+        return _err(PlatformError("platform_unavailable", f"停止失败: {str(e)[:100]}"))
+    audit.audit("de_stop_app", serial, package, "ok")
+    return _ok({"action": "stop_app", "package": package})
+
+
+@mcp.tool()
+def de_foreground_app(serial: str) -> dict:
+    """查询设备当前前台运行的 App 包名（轻量 dumpsys，不打扰设备）。"""
+    try:
+        serial = _check_serial(serial)
+        from mcp_server import direct_ops
+        pkg = direct_ops.foreground_app(serial)
+    except PlatformError as e:
+        return _err(e)
+    except Exception as e:
+        return _err(PlatformError("platform_unavailable", f"查询失败: {str(e)[:100]}"))
+    audit.audit("de_foreground_app", serial, "", pkg or "未知")
+    return _ok({"foreground_app": pkg or ""})
+
+
+@mcp.tool()
+def de_type_text(serial: str, text: str) -> dict:
+    """向设备当前输入框输入文字（支持中文，直接 set_text 不依赖剪贴板）。"""
+    try:
+        _check_write()
+        serial = _check_serial(serial)
+        _ensure_device_free(serial)
+        if not text:
+            raise PlatformError("invalid_param", "内容为空")
+        from mcp_server import direct_ops
+        ok, msg = direct_ops.type_text(serial, text)
+        if not ok:
+            raise PlatformError("device_offline", msg)
+    except PlatformError as e:
+        return _err(e)
+    except Exception as e:
+        return _err(PlatformError("platform_unavailable", f"输入失败: {str(e)[:100]}"))
+    audit.audit("de_type_text", serial, f"{text[:30]}...", "ok")
+    return _ok({"action": "type_text"})
+
+
+@mcp.tool()
+def de_set_clipboard(serial: str, text: str) -> dict:
+    """写入设备剪贴板（ClipInject 通道，读回验证）。"""
+    try:
+        _check_write()
+        serial = _check_serial(serial)
+        _ensure_device_free(serial)
+        if not text:
+            raise PlatformError("invalid_param", "内容为空")
+        from mcp_server import direct_ops
+        ok, msg = direct_ops.set_clipboard(serial, text)
+        if not ok:
+            raise PlatformError("device_offline", msg)
+    except PlatformError as e:
+        return _err(e)
+    except Exception as e:
+        return _err(PlatformError("platform_unavailable", f"注入失败: {str(e)[:100]}"))
+    audit.audit("de_set_clipboard", serial, f"{text[:30]}...", "ok")
+    return _ok({"action": "set_clipboard"})
+
+
+@mcp.tool()
+def de_sleep(serial: str) -> dict:
+    """熄灭设备屏幕（运行中任务会中断，慎用）。"""
+    try:
+        _check_write()
+        serial = _check_serial(serial)
+        _ensure_device_free(serial)
+        platform().sleep(serial)
+    except PlatformError as e:
+        return _err(e)
+    audit.audit("de_sleep", serial, "", "ok")
+    return _ok({"action": "sleep"})
+
+
+@mcp.tool()
+def de_ocr(serial: str) -> dict:
+    """OCR 识别当前屏幕文字（图片/画布/WebView 里 UI 树没有的文字也能识别）。
+
+    返回 [{text, score}]——搜屏幕关键词后可配合 de_tap_element/de_tap 操作。
+    """
+    try:
+        serial = _check_serial(serial)
+        from mcp_server import direct_ops
+        results = direct_ops.ocr(serial)
+    except PlatformError as e:
+        return _err(e)
+    except Exception as e:
+        return _err(PlatformError("platform_unavailable", f"OCR 失败: {str(e)[:100]}"))
+    slim = [{"text": r["text"], "score": round(r["score"], 2)} for r in results]
+    audit.audit("de_ocr", serial, "", f"{len(slim)} 条")
+    return _ok({"count": len(slim), "texts": slim[:100]})
+
+
+@mcp.tool()
+def de_tap_text(serial: str, text: str) -> dict:
+    """点击屏幕上显示该文字的位置（语义点击：一次调用完成「找到并点击」，无需坐标）。
+
+    想点带文字的按钮/列表项/标签/链接时用它：text 只需是屏幕上可见文字的
+    一部分（子串匹配，如「搜索」「立即购买」）。原生控件直接命中；
+    WebView/图片/画布里渲染的文字自动走 OCR 兜底。多命中点第一处（想点
+    更靠下的请把文字换独特些）。屏幕确实没有该文字时返回错误提示，
+    请截图确认后换关键词。比 de_tap 坐标点击可靠，涉及文字目标时优先使用。
+    """
+    try:
+        _check_write()
+        serial = _check_serial(serial)
+        _ensure_device_free(serial)
+        if not text or len(text) > 100:
+            raise PlatformError("invalid_param", "text 不能为空且 ≤100 字符")
+        res = platform().tap_text(serial, text)
+    except PlatformError as e:
+        return _err(e)
+    if not res.get("found"):
+        err = PlatformError("text_not_found",
+                            f"屏幕上未找到文字「{text}」——先 de_screenshot 看当前界面，"
+                            f"换用屏幕上实际存在的文字；若文字在需滑动后才可见请先滑动")
+        audit.audit("de_tap_text", serial, f"「{text[:30]}」", "未找到")
+        return _err(err)
+    audit.audit("de_tap_text", serial,
+                f"「{text[:30]}」via {res.get('method')} @({res.get('x')},{res.get('y')})", "ok")
+    return _ok({"action": "tap_text", "serial": serial, "text": text,
+                "method": res.get("method"), "matched": res.get("matched") or text,
+                "x": res.get("x"), "y": res.get("y")})
+
+
+@mcp.tool()
+def de_list_apps(serial: str, keyword: str = "") -> dict:
+    """列出设备第三方已装应用包名（可关键词过滤，如 keyword='douyin' 找抖音）。"""
+    try:
+        serial = _check_serial(serial)
+        from mcp_server import direct_ops
+        pkgs = direct_ops.list_apps(serial, keyword)
+    except PlatformError as e:
+        return _err(e)
+    except Exception as e:
+        return _err(PlatformError("platform_unavailable", f"查询失败: {str(e)[:100]}"))
+    audit.audit("de_list_apps", serial, keyword or "", f"{len(pkgs)} 个")
+    return _ok({"count": len(pkgs), "packages": pkgs[:200]})
+
+
+@mcp.tool()
+def de_list_tasks() -> dict:
+    """列出平台任务计划（名称/启用状态/调度），供了解可自动化的任务。"""
+    try:
+        tasks = platform().list_tasks()
+    except PlatformError as e:
+        return _err(e)
+    audit.audit("de_list_tasks", "", "", f"{len(tasks)} 个")
+    return _ok({"tasks": tasks})
+
+
+def main():
+    _log.info("MCP mobile-control 启动: allow_write=%s port=%s",
+              S.allow_write, S.http_port)
+    mcp.run(transport="http", host=S.http_host, port=S.http_port)
+
+
+if __name__ == "__main__":
+    main()

mcp_server/platform_client.py

@@ -0,0 +1,186 @@
+"""平台（auto_control）HTTP 客户端：登录会话 + CSRF + API 封装。
+
+会话失效自动重登；CSRF token 每次登录后获取，POST 必带。
+只读接口（GET）与写接口（POST）分离封装，写操作由 MCP 门控层决定是否调用。
+"""
+import httpx
+import logging
+
+_log = logging.getLogger("mcp.platform")
+
+_CSRF_HEADER = "X-CSRF-Token"
+
+
+class PlatformError(Exception):
+    def __init__(self, code, message):
+        super().__init__(message)
+        self.code = code
+        self.message = message
+
+
+class PlatformClient:
+    def __init__(self, url, user, password, timeout=30.0):
+        self.url = url.rstrip("/")
+        self.user = user
+        self.password = password
+        self._client = httpx.Client(base_url=self.url, timeout=timeout,
+                                    follow_redirects=True)
+        self._csrf = ""
+        self._login()
+
+    # ---------- 会话 ----------
+    def _login(self):
+        """登录平台，拿会话 cookie + CSRF token。"""
+        r = self._client.post("/login", data={
+            "username": self.user, "password": self.password})
+        if r.status_code != 302 and r.status_code != 200:
+            raise PlatformError("platform_unavailable",
+                                f"平台登录失败 HTTP {r.status_code}: {r.text[:120]}")
+        csrf = self._client.get("/api/csrf")
+        if csrf.status_code == 200:
+            self._csrf = (csrf.json() or {}).get("token", "")
+        _log.info("平台登录成功: %s", self.user)
+
+    def _ensure_session(self):
+        """会话过期（401/403/302 到登录页）时重登。"""
+        r = self._client.get("/api/status")
+        if r.status_code in (401, 403) or r.url.path.endswith("/login"):
+            _log.warning("会话失效，重新登录")
+            self._login()
+            return True
+        return False
+
+    # ---------- 基础请求 ----------
+    def _get(self, path, **params):
+        self._ensure_session()
+        return self._client.get(path, params=params)
+
+    def _post(self, path, json=None):
+        self._ensure_session()
+        headers = {_CSRF_HEADER: self._csrf} if self._csrf else {}
+        return self._client.post(path, json=json or {}, headers=headers)
+
+    # ---------- 平台 API 封装（M0） ----------
+    def list_devices(self):
+        """设备列表与状态（GET /api/status）。"""
+        r = self._get("/api/status")
+        if r.status_code != 200:
+            raise PlatformError("platform_unavailable",
+                                f"/api/status HTTP {r.status_code}")
+        j = r.json() or {}
+        return j.get("devices", [])
+
+    def screenshot(self, serial):
+        """截图（GET /api/screen/thumb），返回 (jpeg_bytes, screen_state)。"""
+        r = self._get("/api/screen/thumb", serial=serial)
+        if r.status_code == 503:
+            raise PlatformError("device_offline", r.text[:120])
+        if r.status_code != 200:
+            raise PlatformError("platform_unavailable",
+                                f"截图 HTTP {r.status_code}")
+        return r.content, r.headers.get("X-Screen-State", "unknown")
+
+    def screen_size(self, serial):
+        """屏幕原生分辨率（GET /api/screen/size），返回 (w, h)。"""
+        r = self._get("/api/screen/size", serial=serial)
+        if r.status_code == 503:
+            raise PlatformError("device_offline", r.text[:120])
+        if r.status_code != 200:
+            raise PlatformError("platform_unavailable",
+                                f"分辨率 HTTP {r.status_code}")
+        j = r.json() or {}
+        if not j.get("ok"):
+            raise PlatformError("device_offline", str(j.get("error", "取分辨率失败"))[:120])
+        return int(j["width"]), int(j["height"])
+
+    def tap(self, serial, x, y, snap=False):
+        """点击（POST /api/screen/tap）。
+
+        snap=True：点落在可点击元素内则吸附到元素中心（AI 粗略坐标也能点准）。
+        返回平台 JSON（含 snapped/x/y/label）。
+        """
+        r = self._post("/api/screen/tap", json={"serial": serial,
+                                                "x": int(x), "y": int(y),
+                                                "snap": 1 if snap else 0})
+        return self._check_op(r, "tap")
+
+    def tap_text(self, serial, text):
+        """按屏幕文字点击（平台解析：UI 树子串匹配 → OCR 兜底）。
+
+        返回 {ok, found, method, matched, x, y}——found=false 是业务结果
+        （屏幕无该文字），非设备错误；设备离线/不可达仍抛 PlatformError。
+        """
+        r = self._post("/api/screen/tap_text",
+                       json={"serial": serial, "text": str(text)})
+        if r.status_code == 503:
+            raise PlatformError("device_offline", r.text[:120])
+        if r.status_code != 200:
+            raise PlatformError("platform_unavailable",
+                                f"tap_text HTTP {r.status_code}: {r.text[:120]}")
+        return r.json() or {}
+
+    def swipe(self, serial, x1, y1, x2, y2, duration=0.2):
+        """滑动（POST /api/screen/swipe）。"""
+        r = self._post("/api/screen/swipe", json={
+            "serial": serial, "x1": int(x1), "y1": int(y1),
+            "x2": int(x2), "y2": int(y2),
+            "duration": float(duration)})
+        return self._check_op(r, "swipe")
+
+    def ui_elements(self, serial):
+        """UI 元素树（GET /api/uiauto/elements，uiautodev 服务）。"""
+        r = self._get("/api/uiauto/elements", serial=serial)
+        if r.status_code == 503:
+            raise PlatformError("device_offline", r.text[:120])
+        if r.status_code != 200:
+            raise PlatformError("platform_unavailable",
+                                f"元素树 HTTP {r.status_code}")
+        j = r.json() or {}
+        if not j.get("ok"):
+            raise PlatformError("device_offline", str(j.get("error", "取元素失败"))[:120])
+        return j.get("elements", [])
+
+    def wake(self, serial):
+        """亮屏并解锁（POST /api/device/screen_all mode=on）。"""
+        r = self._post("/api/device/screen_all",
+                       json={"mode": "on", "serials": [serial]})
+        return self._check_op(r, "wake")
+
+    def sleep(self, serial):
+        """熄屏（POST /api/device/screen_all mode=off）。"""
+        r = self._post("/api/device/screen_all",
+                       json={"mode": "off", "serials": [serial]})
+        return self._check_op(r, "sleep")
+
+    def list_tasks(self):
+        """任务计划列表（GET /api/jobs）。"""
+        r = self._get("/api/jobs")
+        if r.status_code != 200:
+            raise PlatformError("platform_unavailable",
+                                f"/api/jobs HTTP {r.status_code}")
+        j = r.json() or {}
+        tasks = []
+        for t in j.get("jobs") or []:
+            tasks.append({"id": t.get("id"), "name": t.get("name"),
+                          "task_type": t.get("task_type"),
+                          "enabled": t.get("enabled"),
+                          "schedule": (t.get("schedule") or {}).get("mode", "")})
+        return tasks
+
+    def press_key(self, serial, key):
+        """按键（POST /api/screen/key）。"""
+        r = self._post("/api/screen/key",
+                       json={"serial": serial, "key": key})
+        return self._check_op(r, "key")
+
+    @staticmethod
+    def _check_op(r, name):
+        if r.status_code == 503:
+            raise PlatformError("device_offline", r.text[:120])
+        if r.status_code != 200:
+            raise PlatformError("platform_unavailable",
+                                f"{name} HTTP {r.status_code}: {r.text[:120]}")
+        j = r.json() or {}
+        if not j.get("ok"):
+            raise PlatformError("device_offline", str(j.get("error", "操作失败"))[:120])
+        return j

mcp_server/requirements.txt

@@ -0,0 +1,3 @@
+fastmcp>=2.0
+httpx>=0.27
+Pillow>=10.0

requirements.txt

@@ -15,10 +15,10 @@ Flask-SQLAlchemy>=3.0,<4.0
 # 定时任务调度
 APScheduler>=3.10,<4.0
 
-# HTTP 客户端（STF API 调用）
+# HTTP 客户端
 requests>=2.28
 
-# SSH 远程执行（STF 重启 / STF 设备管理；.env 配 STF_SSH_PASSWORD 时走密码认证，
+# SSH 远程执行（预留运维用；.env 配 STF_SSH_PASSWORD 时走密码认证，
 # 跨平台无需 sshpass；未配置则退回系统 ssh 免密密钥）
 paramiko>=3.0
 
@@ -29,8 +29,13 @@ uiautomator2>=3.0
 uiautodev>=0.14
 
 # 屏幕 OCR（条件判断的 OCR识别 选择器，ONNX 推理，跨平台：Windows/Linux/macOS，
-# 中英文模型随包内置；服务器无显示器环境建议把 opencv-python 换成 opencv-python-headless）
+# 中英文模型随包内置；服务器/容器环境必须用 headless 版 opencv——
+# opencv-python 依赖 X11 库（libxcb），slim 容器里 import cv2 直接崩，OCR 步骤任务失败退出）
 rapidocr_onnxruntime>=1.4
+opencv-python-headless>=4.8,<5  # 锁定 4.x：5.x wheel 打包异常（无 cv2 模块）
 
 # APK 元信息解析（应用管理功能：自动读取包名/版本/应用名）
 pyaxmlparser>=0.3.27
+
+# MCP Server + AI 控制台 Agent（fastmcp：Streamable HTTP 服务端/客户端）
+fastmcp>=2.0

scripts/regression_test.py

@@ -0,0 +1,167 @@
+"""全量路由回归测试：启动后遍历所有 API 路由发请求，抓 500/异常。
+
+用法（项目根目录）：
+    .venv/bin/python scripts/regression_test.py
+
+设计：
+  - 用 Flask test_client（不占用 18050，不影响运行中的服务）
+  - GET 路由全量请求（路径参数自动替换）；流式/二进制接口跳过
+  - 写操作（POST/PUT/DELETE）发空 body 探测：期望 400/403/404（参数校验），
+    返回 500 = 代码缺陷（import 遗漏/引用错误），立即报出
+  - 关键业务 POST 用真实参数验证（亮屏/剪贴板/测试步骤/设备池增删）
+  - 退出码：有失败返回 1（可接入检查流程）
+
+背景：web/ 蓝图拆分后多次出现 import 遗漏导致接口 500（ADB_PATH/_log/常量等），
+每次都是线上报错才暴露。此脚本让这类问题在改动后 30 秒内现形。
+"""
+import os
+import sys
+import signal
+
+# 项目根加入 sys.path（脚本在 scripts/ 下运行，保证可 import web_server/config）
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+# 测试模式：禁用 cron 调度器（否则 test_client 会按 DB 里的任务 cron 真跑任务，
+# 干扰回归/占用设备——实测 ocr关键字任务每 30 分钟触发导致回归超时）
+os.environ["DISABLE_SCHEDULER"] = "1"
+
+# 单接口超时保护：adb 相关接口可能慢（连接/查询设备），给足时间
+signal.alarm(300)
+
+from web_server import app  # noqa: E402  （导入即完成 app 装配，与生产一致）
+
+
+# 流式/二进制接口：无法用普通 GET 断言，跳过（已有单独验证路径）
+_SKIP_PREFIXES = (
+    "/api/screen/stream", "/api/screen/thumb",
+    "/api/uiauto/screenshot", "/api/device/screenshot",
+)
+# 关键业务 POST：用真实参数验证（这些覆盖了核心链路）
+_KEY_POSTS = [
+    ("一键亮屏", "/api/device/screen_all", {"mode": "on"}),
+    ("一键息屏", "/api/device/screen_all", {"mode": "off"}),
+    ("剪贴板注入", "/api/tools/clipboard/set",
+     {"serials": ["100.100.10.11:5555"], "text": "回归测试"}),
+    ("测试步骤(wait)", "/api/steps/test",
+     {"serial": "100.100.10.11:5555",
+      "step": {"type": "wait", "label": "等待", "params": {"max": 1, "min": 1, "probability": 100}}}),
+    ("adb 终端执行", "/api/adb/cmd", {"cmd": "adb devices"}),
+    ("adb 红线拦截", "/api/adb/cmd", {"cmd": "adb kill-server"}),
+    ("应用版本查询", "/api/tools/appver", {"pkg": "jp.co.cyberagent.stf"}),
+]
+# 红线接口：期望被拒绝（不是 ok）
+_EXPECT_REJECT = {"/api/adb/cmd"}
+
+
+def _fill_path_params(rule):
+    """把路由路径参数 <xxx> 替换为测试值（serial 用真实设备）。"""
+    url = rule
+    url = url.replace("<serial>", "100.100.10.11:5555")
+    url = url.replace("<apk_id>", "x")
+    url = url.replace("<action_id>", "x")
+    url = url.replace("<device_id>", "x")
+    url = url.replace("<uid>", "1")
+    return url
+
+
+def main():
+    c = app.test_client()
+    # 登录 + CSRF
+    r = c.post("/login", data={"username": "admin", "password": "admin123"})
+    if r.status_code != 302:
+        print("❌ 登录失败（请检查 admin 账号）")
+        sys.exit(1)
+    token = c.get("/api/csrf").get_json()["token"]
+    H = {"X-CSRF-Token": token}
+
+    fails = []
+    warns = []
+    passed = 0
+
+    # ========== 1. GET 全量 ==========
+    rules = sorted({r.rule for r in app.url_map.iter_rules()
+                    if r.rule.startswith("/api") and "GET" in r.methods})
+    for rule in rules:
+        if rule.startswith(_SKIP_PREFIXES):
+            continue
+        url = _fill_path_params(rule)
+        try:
+            r = c.get(url)
+            if r.status_code == 500:
+                fails.append(f"GET {rule} -> HTTP 500（代码缺陷）")
+            elif r.status_code >= 502:
+                warns.append(f"GET {rule} -> HTTP {r.status_code}（业务错误，如未配置/设备离线）")
+            else:
+                passed += 1
+        except Exception as e:
+            fails.append(f"GET {rule} -> {type(e).__name__}: {e}")
+    print(f"GET 路由: {len(rules)} 个（跳过 {len([r for r in rules if r.startswith(_SKIP_PREFIXES)])} 个流式/二进制）")
+
+    # ========== 1.5 未登录访问（登录重定向链路） ==========
+    try:
+        r = c.get("/")
+        if r.status_code == 302 and "login" in (r.headers.get("Location") or ""):
+            passed += 1
+        elif r.status_code == 200:
+            passed += 1  # 已登录态也可能 200（测试客户端无 cookie 时走 302）
+        else:
+            fails.append(f"未登录访问 / -> HTTP {r.status_code}（应 302 到登录页）")
+    except Exception as e:
+        fails.append(f"未登录访问 / -> {type(e).__name__}: {e}")
+
+    # ========== 2. 写操作空 body 探测（抓 import 遗漏/引用错误） ==========
+    write_rules = sorted({r.rule for r in app.url_map.iter_rules()
+                          if r.rule.startswith("/api")
+                          and (r.methods & {"POST", "PUT", "DELETE"})})
+    for rule in write_rules:
+        url = _fill_path_params(rule)
+        try:
+            methods = {m for r2 in app.url_map.iter_rules() if r2.rule == rule for m in r2.methods}
+            if "DELETE" in methods:
+                r = c.delete(url, headers=H)
+            elif "PUT" in methods:
+                r = c.put(url, json={}, headers=H)
+            else:
+                r = c.post(url, json={}, headers=H)
+            # 空 body 期望 400（参数校验）；403=权限/404=路径参数、500=代码缺陷
+            if r.status_code == 500:
+                fails.append(f"写操作 {rule} -> HTTP 500（空 body 应 400，500=代码缺陷）")
+            elif r.status_code >= 502:
+                warns.append(f"写操作 {rule} -> HTTP {r.status_code}（业务错误，如未配置/设备离线）")
+            else:
+                passed += 1
+        except Exception as e:
+            fails.append(f"写操作 {rule} -> {type(e).__name__}: {e}")
+    print(f"写操作路由: {len(write_rules)} 个（空 body 探测）")
+
+    # ========== 3. 关键业务 POST（真实参数） ==========
+    for name, url, body in _KEY_POSTS:
+        try:
+            r = c.post(url, json=body, headers=H)
+            j = r.get_json() if r.is_json else None
+            is_reject = url in _EXPECT_REJECT and "kill" in (body.get("cmd") or "")
+            good = (not j.get("ok")) if is_reject else bool(j and j.get("ok") is not False)
+            if good:
+                passed += 1
+                print(f"  ✅ {name}: {r.status_code}")
+            else:
+                fails.append(f"关键 POST {name} -> HTTP {r.status_code} {str(j)[:80]}")
+        except Exception as e:
+            fails.append(f"关键 POST {name} -> {type(e).__name__}: {e}")
+
+    # ========== 汇总 ==========
+    print("-" * 50)
+    if warns:
+        print(f"⚠ 业务性提示 {len(warns)} 个（非代码缺陷）：")
+        for w in warns:
+            print("   ", w)
+    if fails:
+        print(f"❌ 发现 {len(fails)} 个代码缺陷：")
+        for f in fails:
+            print("   ", f)
+        sys.exit(1)
+    print(f"✅ 全部通过（{passed} 项检查，含 {len(rules)} GET + {len(write_rules)} 写操作探测 + {len(_KEY_POSTS)} 关键业务）")
+
+
+if __name__ == "__main__":
+    main()

scripts/start.sh

@@ -0,0 +1,81 @@
+#!/bin/bash
+# 容器启动脚本：依赖安装（仅首次/缺失时）+ 环境修复 + 启动 web_server。
+# compose 的 python-app 服务 command 指向本脚本（不要在 compose 里再跑 pip，
+# 否则每次容器重启都重装依赖——实测每轮重新下载 opencv 5.0(73MB) 并破坏 cv2）。
+#
+# 为什么需要环境修复（必须在 pip install 之后）：
+#   rapidocr_onnxruntime 的依赖声明是 opencv-python（GUI 版），pip 解析依赖时
+#   会强制装回它；而 GUI 版依赖 X11 库（libxcb），python:slim 容器里 import cv2
+#   直接崩溃 → RapidOCR 不可用 → 条件判断的 OCR 步骤抛异常 → 任务失败退出。
+#   因此在安装完 requirements 后，最后强制卸载 GUI 版并装 headless（幂等）。
+#   本地 Mac 有 GUI 环境不受影响。
+
+# ---- 依赖就绪守卫：flask/u2/uiautodev/rapidocr/cv2 全部可用则跳过安装 ----
+# （容器重启秒级启动；只有首次部署或依赖缺失时才走完整安装）
+python3 - <<'PY'
+import importlib.util, sys
+mods = ("flask", "flask_login", "flask_sqlalchemy", "apscheduler",
+        "uiautomator2", "uiautodev", "rapidocr_onnxruntime", "PIL",
+        "fastmcp")
+if all(importlib.util.find_spec(m) for m in mods):
+    try:
+        import cv2
+        ok = hasattr(cv2, "__version__") and cv2.__file__ is not None
+    except Exception:
+        ok = False
+    sys.exit(0 if ok else 1)
+sys.exit(1)
+PY
+if [ $? -ne 0 ]; then
+    echo "[start] 依赖缺失或 cv2 异常，执行安装与环境修复（首次启动较慢）..."
+    if [ -f requirements.txt ]; then
+        pip install --no-cache-dir -i https://pypi.tuna.tsinghua.edu.cn/simple -r requirements.txt
+    fi
+
+    # 环境修复：最后强制 headless（覆盖 rapidocr 拉回的 GUI 版）
+    pip uninstall -y -q opencv-python 2>/dev/null || true
+    pip install -q -i https://pypi.tuna.tsinghua.edu.cn/simple "opencv-python-headless>=4.8,<5"  # 5.x wheel 无 cv2 模块，锁定 4.x
+
+    # pip 24.0 解压 abi3 wheel 偶发丢根文件（site-packages/cv2 只剩子目录，
+    # cv2.abi3.so / __init__.py 缺失 → import cv2 成空壳，OCR 全挂）。
+    # 手动解压兜底在部分环境修不好（解压后仍无 cv2.__version__），
+    # 实测 pip --force-reinstall 完整安装有效（220 验证 cv2 4.14.0 恢复）。
+    python3 - <<'PY'
+import subprocess, sys
+
+def cv2_ok():
+    try:
+        import cv2
+        return hasattr(cv2, "__version__") and cv2.__file__ is not None
+    except Exception:
+        return False
+
+if cv2_ok():
+    sys.exit(0)
+print("cv2 异常，pip 强制重装 opencv-python-headless...")
+r = subprocess.run(["pip", "install", "--force-reinstall", "-q",
+                    "-i", "https://pypi.tuna.tsinghua.edu.cn/simple",
+                    "opencv-python-headless>=4.8,<5"])
+if r.returncode == 0:
+    import cv2
+    print(f"cv2 {cv2.__version__} 重装修复完成")
+sys.exit(r.returncode)
+PY
+else
+    echo "[start] 依赖已就绪（cv2 $(python3 -c 'import cv2; print(cv2.__version__)' 2>/dev/null)），跳过安装"
+fi
+
+# 启动 MCP server（后台，AI 控制台/外部客户端经 127.0.0.1:8033 调用）。
+# web_server.py 内 agent 依赖它，容器重启必须自动拉起（MCP_ENABLED=0 可关）。
+# 平台账号：MCP_PLATFORM_USER 默认 admin；密码优先取环境变量（compose/.env），
+# 兜底 admin123 与部署时的手动启动参数一致。
+if [ -f mcp_server/mcp_server.py ] && [ "${MCP_ENABLED:-1}" = "1" ]; then
+    echo "[start] 启动 MCP server..."
+    MCP_ALLOW_WRITE=1 \
+    MCP_PLATFORM_USER="${MCP_PLATFORM_USER:-admin}" \
+    MCP_PLATFORM_PASS="${MCP_PLATFORM_PASS:-admin123}" \
+    MCP_AUDIT_FILE="${MCP_AUDIT_FILE:-/tmp/mcp_audit.log}" \
+    python3 -m mcp_server.mcp_server > /tmp/mcp_server.log 2>&1 &
+fi
+
+exec python -u web_server.py

static/admin/agent.js

@@ -0,0 +1,586 @@
+// AI 控制台（顶级 Tab）：DeepSeek 风格聊天 + 流式输出 + 实时 MCP 步骤
+let _agentBusy = false;
+let _agentStream = null;      // EventSource
+let _agentCfgLoaded = false;
+
+// ================== 初始化 ==================
+let _agentDefaultSerial = '';
+function initAgentChat(){
+  if(_agentCfgLoaded)return;
+  _agentCfgLoaded = true;
+  loadAgentConfig();
+  const chat = document.getElementById('agent-chat');
+  if(chat && !chat.children.length){
+    chat.innerHTML = '<div class="agent-empty">👋 给 AI 下达指令，它将通过截图观察手机并执行操作。<br>'
+      + '例如：「打开抖音搜索奚学东，告诉我第一个视频的标题」<br>'
+      + '先选「🎯 目标设备」（AI 只操作你选定的设备），点击右上角 ⚙ 配置模型与 API Key。</div>';
+  }
+  bindChatScroll();
+  loadLiveDevices();
+  loadAgentTargetDevices();
+  startRunPoll();
+  renderConvList();           // 会话列表（决定当前会话）
+  loadCurrentConvMessages();  // 渲染当前会话历史
+  restoreRunningFlow();       // 若任务运行中：重订阅事件流
+  // 输入框快捷键
+  const inp = document.getElementById('agent-input');
+  inp.addEventListener('keydown', ev=>{
+    if(ev.key==='Enter' && !ev.shiftKey){
+      ev.preventDefault();
+      if(!_agentBusy) sendAgentMsg();
+    }
+  });
+}
+
+// ================== 页面刷新/重进恢复（运行中任务续流） ==================
+// 历史轮次由 loadCurrentConvMessages 从会话渲染；这里只处理「任务仍在后台跑」：
+// 重新订阅事件流（服务端队列保留积压，重连后补发 delta/step/done）。
+function restoreRunningFlow(){
+  apiGet('/api/agent/run').then(r=>{
+    if(!r||!r.ok) return;
+    if(r.state === 'running' && r.run_id){
+      setRunning(true);
+      listenStream(r.run_id);
+    }else if(r.state === 'error' && r.error && _currentConvId){
+      // 错误提示仅当本会话相关时展示
+      const chat = document.getElementById('agent-chat');
+      if(chat && !chat.children.length){
+        const div = newAssistantMsg();
+        div.querySelector('.agent-text').textContent = '⚠ ' + r.error;
+      }
+    }
+  });
+}
+
+// ================== 配置 ==================
+function loadAgentConfig(){
+  apiGet('/api/agent/config').then(r=>{
+    if(!r||!r.ok)return;
+    const tag = document.getElementById('agent-model-tag');
+    if(tag && r.model) tag.textContent = r.model;
+    _agentDefaultSerial = r.default_serial || '';
+  });
+}
+
+// ================== 目标设备选择（AI 只操作选定设备） ==================
+function loadAgentTargetDevices(){
+  apiGet('/api/agent/devices').then(r=>{
+    if(!r||!r.ok)return;
+    const sel = document.getElementById('agent-target-select');
+    if(!sel)return;
+    const cur = sel.value;
+    const devs = (r.devices||[]).filter(x=>x.online);
+    sel.innerHTML = '<option value="">请选择设备（AI 只操作选定设备）…</option>'
+      + devs.map(d=>{
+          const label = d.serial + (d.model ? ' · ' + d.model : '')
+            + (d.busy ? ' ⛔ 任务中：' + d.task_job : '');
+          return '<option value="'+esc(d.serial)+'"' + (d.busy ? ' disabled' : '')
+            + '>' + esc(label) + '</option>';
+        }).join('');
+    // 保留当前选择；否则预选配置的默认设备
+    if(cur && [...sel.options].some(o=>o.value===cur)) sel.value = cur;
+    else if(_agentDefaultSerial && [...sel.options].some(o=>o.value===_agentDefaultSerial))
+      sel.value = _agentDefaultSerial;
+    const hint = document.getElementById('agent-target-hint');
+    if(hint && sel.value) hint.textContent = '将操作：' + sel.value;
+  });
+}
+
+// ================== 跨窗口运行状态（多人/多窗口可见并可停止） ==================
+let _runPoll = null;
+function startRunPoll(){
+  if(_runPoll) return;
+  _runPoll = setInterval(pollRunState, 8000);
+}
+function pollRunState(){
+  if(_agentStream) return;   // 本窗口正在跑（事件流驱动），不轮询
+  apiGet('/api/agent/run').then(r=>{
+    if(!r||!r.ok)return;
+    const running = r.state === 'running';
+    document.getElementById('agent-running-tag').style.display = running ? 'inline' : 'none';
+    document.getElementById('btn-agent-stop').style.display = running ? 'inline-block' : 'none';
+    const hint = document.getElementById('agent-target-hint');
+    if(hint){
+      hint.textContent = running
+        ? ('⏳ 运行中' + (r.started ? ' ' + r.started + ' 起' : '')
+           + (r.serial ? ' · ' + r.serial : '')
+           + '：' + (r.prompt||'').slice(0,70))
+        : (document.getElementById('agent-target-select').value
+           ? '将操作：' + document.getElementById('agent-target-select').value : '');
+    }
+    document.getElementById('btn-agent-send').disabled = running;
+    if(!running && _agentBusy){ setRunning(false); }   // 流异常丢失时复位
+  });
+}
+function openAgentConfig(){
+  apiGet('/api/agent/config').then(r=>{
+    if(!r||!r.ok)return;
+    document.getElementById('acfg-base').value = r.api_base || 'https://api.deepseek.com';
+    document.getElementById('acfg-model').value = r.model || '';
+    document.getElementById('acfg-serial').value = r.default_serial || '';
+    document.getElementById('acfg-steps').value = r.max_steps || 40;
+    document.getElementById('acfg-key-hint').textContent =
+      r.api_key_masked ? ('已配置 ' + r.api_key_masked) : '未配置';
+    document.getElementById('acfg-key').value = '';
+    document.getElementById('agent-cfg-overlay').style.display = 'flex';
+  });
+}
+function closeAgentConfig(){
+  document.getElementById('agent-cfg-overlay').style.display = 'none';
+}
+function saveAgentConfig(){
+  const body = {
+    api_base: document.getElementById('acfg-base').value.trim(),
+    model: document.getElementById('acfg-model').value.trim(),
+    default_serial: document.getElementById('acfg-serial').value.trim(),
+    max_steps: document.getElementById('acfg-steps').value.trim(),
+  };
+  const key = document.getElementById('acfg-key').value.trim();
+  if(key) body.api_key = key;
+  apiPost('/api/agent/config', body).then(r=>{
+    if(r&&r.ok){
+      showToast('配置已保存','success');
+      closeAgentConfig();
+      loadAgentConfig();
+      loadAgentTargetDevices();
+    }else showToast('保存失败: ' + ((r&&r.error)||''),'error');
+  });
+}
+
+// ================== 聊天渲染 ==================
+function addUserMsg(text){
+  const chat = document.getElementById('agent-chat');
+  clearEmpty();
+  const div = document.createElement('div');
+  div.className = 'agent-msg user';
+  div.textContent = text;
+  chat.appendChild(div);
+  scrollChat();
+}
+function newAssistantMsg(){
+  const chat = document.getElementById('agent-chat');
+  clearEmpty();
+  const div = document.createElement('div');
+  div.className = 'agent-msg assistant';
+  div.innerHTML = '<div class="agent-toolcards"></div><div class="agent-text"></div>';
+  chat.appendChild(div);
+  scrollChat();
+  return div;
+}
+function clearEmpty(){
+  const empty = document.querySelector('#agent-chat .agent-empty');
+  if(empty) empty.remove();
+}
+let _chatPinned = true;   // 用户是否在底部（贴底才自动跟随滚动）
+function scrollChat(force){
+  const chat = document.getElementById('agent-chat');
+  if(force || _chatPinned){
+    chat.scrollTop = chat.scrollHeight;
+  }
+}
+function bindChatScroll(){
+  const chat = document.getElementById('agent-chat');
+  chat.addEventListener('scroll', ()=>{
+    _chatPinned = chat.scrollHeight - chat.scrollTop - chat.clientHeight < 60;
+  });
+}
+function clearAgentChat(){
+  document.getElementById('agent-chat').innerHTML = '';
+}
+
+// ================== 历史会话（DeepSeek 式：左侧列表，多会话持久化） ==================
+let _currentConvId = localStorage.getItem('agent_conv_id') || '';
+function saveConvId(id){
+  _currentConvId = id || '';
+  if(id) localStorage.setItem('agent_conv_id', id);
+  else localStorage.removeItem('agent_conv_id');
+}
+function createAgentSession(){
+  if(_agentBusy){showToast('运行中不能新建会话','error');return;}
+  apiPost('/api/agent/conversations',{}).then(r=>{
+    if(r&&r.ok){
+      saveConvId(r.id);
+      clearAgentChat();
+      showToast('已新建会话','success');
+      renderConvList();
+    }else showToast('新建失败: '+((r&&r.error)||''),'error');
+  });
+}
+function selectAgentSession(id){
+  if(_agentBusy){showToast('运行中不能切换会话','error');return;}
+  if(id === _currentConvId) return;
+  saveConvId(id);
+  clearAgentChat();
+  loadCurrentConvMessages();
+  renderConvList();
+}
+function deleteAgentSession(id){
+  if(!confirm('删除该会话？历史消息将不可恢复。')) return;
+  apiDelete('/api/agent/conversations/'+id).then(r=>{
+    if(r&&r.ok){
+      if(_currentConvId === id) saveConvId('');
+      showToast('会话已删除','success');
+      renderConvList();
+      loadCurrentConvMessages();
+    }else showToast('删除失败: '+((r&&r.error)||''),'error');
+  });
+}
+function renderConvList(){
+  apiGet('/api/agent/conversations').then(r=>{
+    if(!r||!r.ok)return;
+    const list = document.getElementById('agent-sess-list');
+    if(!list)return;
+    const convs = r.conversations || [];
+    let cur = _currentConvId;
+    if(!convs.some(c=>c.id===cur)) cur = convs.length ? convs[0].id : '';
+    if(cur !== _currentConvId){ saveConvId(cur); clearAgentChat(); loadCurrentConvMessages(); }
+    if(!convs.length){
+      list.innerHTML = '<div class="agent-empty" style="padding:20px 10px;font-size:12px">'
+        + '暂无历史会话<br><br>点「＋ 新建会话」开始</div>';
+      return;
+    }
+    list.innerHTML = convs.map(c=>{
+      const t = c.title || '新会话';
+      return '<div class="agent-sess-item'+(c.id===cur?' active':'')
+        +'" onclick="selectAgentSession(\''+c.id+'\')">'
+        +'<button class="agent-sess-del" title="删除会话" '
+        +'onclick="event.stopPropagation();deleteAgentSession(\''+c.id+'\')">✕</button>'
+        +'<div class="t">'+esc(t)+'</div>'
+        +'<div class="m">'+esc(c.updated_at||'')+(c.count ? ' · '+c.count+' 轮' : '')+'</div></div>';
+    }).join('');
+  });
+}
+function loadCurrentConvMessages(){
+  const chat = document.getElementById('agent-chat');
+  if(!chat) return;
+  if(!_currentConvId){
+    chat.innerHTML = '<div class="agent-empty">👋 点左侧「＋ 新建会话」开始，'
+      + '给 AI 下达指令（先选 🎯 目标设备）。</div>';
+    return;
+  }
+  apiGet('/api/agent/conversations/'+_currentConvId).then(r=>{
+    if(!r||!r.ok)return;
+    chat.innerHTML = '';
+    (r.messages||[]).forEach(m=>{
+      const txt = (m.content||'').trim();
+      if(!txt) return;
+      if(m.role==='user'){ addUserMsg(txt); }
+      else{
+        const div = newAssistantMsg();
+        div.querySelector('.agent-text').textContent = txt;
+      }
+    });
+    if(!chat.children.length){
+      chat.innerHTML = '<div class="agent-empty">新会话。给 AI 下达指令'
+        + '（先选 🎯 目标设备）…</div>';
+    }
+  });
+}
+
+// ================== 发送与流式接收 ==================
+function setRunning(on){
+  _agentBusy = on;
+  document.getElementById('agent-running-tag').style.display = on ? 'inline' : 'none';
+  document.getElementById('btn-agent-stop').style.display = on ? 'inline-block' : 'none';
+  document.getElementById('btn-agent-send').disabled = on;
+}
+function stopAgent(){
+  if(!confirm('确定停止当前 AI 运行任务？\n（其他人发起的任务也会被停止）')) return;
+  apiPost('/api/agent/stop',{}).then(r=>{
+    if(r&&r.ok) showToast('已请求停止，正在中断…','success');
+    else showToast((r&&r.error)||'停止失败','error');
+  });
+}
+function sendAgentMsg(){
+  if(_agentBusy){showToast('上一轮还在运行','error');return;}
+  const sel = document.getElementById('agent-target-select');
+  const serial = sel ? sel.value : '';
+  if(!serial){
+    showToast('请先选择目标设备（AI 只操作你选定的设备；任务中的设备不可选）','error');
+    if(sel) sel.focus();
+    return;
+  }
+  const inp = document.getElementById('agent-input');
+  const text = inp.value.trim();
+  if(!text){showToast('请输入指令','error');return;}
+  inp.value = '';
+  addUserMsg(text);
+
+  // 会话：无当前会话时自动新建（DeepSeek 式：消息总归属于一个会话）
+  const doRun = (convId)=>{
+    apiPost('/api/agent/run', {prompt: text, serial: serial,
+                               conversation_id: convId}).then(r=>{
+      if(!r||!r.ok){
+        const msg = r ? (r.error||'启动失败') : '请求失败';
+        const div = newAssistantMsg();
+        div.querySelector('.agent-text').textContent = '⚠ ' + msg;
+        showToast(msg,'error');
+        return;
+      }
+      setRunning(true);
+      listenStream(r.run_id);
+    });
+  };
+  if(_currentConvId){
+    doRun(_currentConvId);
+  }else{
+    apiPost('/api/agent/conversations',{}).then(r=>{
+      if(r&&r.ok){
+        saveConvId(r.id);
+        renderConvList();
+        doRun(r.id);
+      }else{
+        const div = newAssistantMsg();
+        div.querySelector('.agent-text').textContent = '⚠ 新建会话失败';
+        showToast('新建会话失败','error');
+      }
+    });
+  }
+}
+
+function listenStream(runId){
+  if(_agentStream) _agentStream.close();
+  const es = new EventSource('/api/agent/stream?run_id=' + runId);
+  _agentStream = es;
+  let msgEl = null;
+
+  es.addEventListener('delta', ev=>{
+    if(!msgEl) msgEl = newAssistantMsg();
+    const d = JSON.parse(ev.data);
+    const textEl = msgEl.querySelector('.agent-text');
+    if(d.kind === 'reasoning'){
+      let r = msgEl.querySelector('.reasoning');
+      if(!r){
+        r = document.createElement('div');
+        r.className = 'reasoning';
+        msgEl.insertBefore(r, textEl);
+      }
+      r.textContent += d.text;
+    }else{
+      textEl.textContent += d.text;
+    }
+    scrollChat();
+  });
+
+  es.addEventListener('step', ev=>{
+    const d = JSON.parse(ev.data);
+    followSerialFromArgs(d.args);
+    if(!msgEl) msgEl = newAssistantMsg();
+    const cards = msgEl.querySelector('.agent-toolcards');
+    const card = document.createElement('div');
+    card.className = 'agent-toolcard';
+    const argsTxt = typeof d.args === 'string' ? d.args
+                    : JSON.stringify(d.args || {});
+    card.innerHTML = '<span class="dot"></span>'
+      + '<code style="color:var(--teal)">' + esc(d.tool||'') + '</code>'
+      + '<span class="text-muted">' + esc(argsTxt) + '</span>';
+    if(d.image){
+      const img = document.createElement('img');
+      img.src = 'data:image/jpeg;base64,' + d.image;
+      card.appendChild(img);
+    }
+    cards.appendChild(card);
+    scrollChat();
+  });
+
+  es.addEventListener('done', ev=>{
+    const d = JSON.parse(ev.data);
+    if(d.answer){
+      if(!msgEl) msgEl = newAssistantMsg();
+      msgEl.querySelector('.agent-text').textContent = d.answer;
+    }
+    endRun();
+    renderConvList();   // 落库已完成：刷新标题/时间/轮数
+  });
+
+  es.addEventListener('error', ev=>{
+    let msg = '连接中断';
+    try{
+      if(ev.data) msg = JSON.parse(ev.data).message || msg;
+    }catch(e){}
+    if(!msgEl) msgEl = newAssistantMsg();
+    msgEl.querySelector('.agent-text').textContent = '⚠ ' + msg;
+    endRun();
+  });
+
+  es.onerror = ()=>{
+    // 重要：不能在这里 endRun()——断网/后台标签页节流/服务端瞬时抖动都会触发
+    // onerror，但后端任务仍在跑。EventSource 会自动重连，服务端事件队列保留
+    // 积压（delta/step/done），重连成功后全部补发，界面无缝续上。
+    // 只有连接彻底关闭（非自动重连态）且任务还在跑时才提示。
+    if(_agentBusy && es.readyState === EventSource.CLOSED){
+      const hint = document.getElementById('agent-target-hint');
+      if(hint) hint.textContent = '⚠ 实时连接已中断，任务仍在后台运行——可刷新页面恢复查看';
+      // 连接彻底失败时周期探测，恢复后重订阅
+      setTimeout(()=>{
+        if(!_agentStream && _agentBusy){
+          apiGet('/api/agent/run').then(r=>{
+            if(r&&r.ok&&r.state==='running'&&r.run_id) listenStream(r.run_id);
+          });
+        }
+      }, 5000);
+    }
+  };
+}
+
+// ============ 实时画面（右侧，MJPEG 流） ============
+let _liveSerial = '';
+function showLive(serial){
+  if(!serial || serial === _liveSerial) return;
+  _liveSerial = serial;
+  const img = document.getElementById('agent-live-img');
+  img.src = '/api/screen/stream?serial=' + encodeURIComponent(serial) + '&q=80&fps=8&t=' + Date.now();
+  img.style.display = 'block';
+  document.getElementById('agent-live-empty').style.display = 'none';
+  document.getElementById('agent-live-serial').textContent = serial;
+  const sel = document.getElementById('agent-live-select');
+  if(sel) sel.value = serial;
+}
+function stopLive(){
+  _liveSerial = '';
+  const img = document.getElementById('agent-live-img');
+  img.src = '';
+  img.style.display = 'none';
+  document.getElementById('agent-live-empty').style.display = 'block';
+  document.getElementById('agent-live-serial').textContent = '';
+}
+function followSerialFromArgs(args){
+  // 工具 args（后端 SSE 已序列化为对象；兼容历史字符串格式）
+  let a = args;
+  if(typeof args === 'string'){
+    try{ a = JSON.parse(args); }catch(e){ return; }
+  }
+  if(a && a.serial) showLive(a.serial);
+}
+function watchDevice(serial){
+  if(!serial){ stopLive(); return; }
+  showLive(serial);
+}
+function loadLiveDevices(){
+  apiGet('/api/devices').then(r=>{
+    if(!r||!r.ok)return;
+    const sel = document.getElementById('agent-live-select');
+    if(!sel)return;
+    const cur = sel.value;
+    const devs = (r.devices||[]).filter(x=>x.indexOf(':')>=0);
+    sel.innerHTML = '<option value="">选择设备观看…</option>'
+      + devs.map(s=>'<option value="'+esc(s)+'"'+(s===cur?' selected':'')+'>'+esc(s)+'</option>').join('');
+  });
+}
+
+// 截图点击放大查看
+function zoomScreenshot(img){
+  const ov = document.getElementById('agent-zoom');
+  if(!ov){
+    const d = document.createElement('div');
+    d.id = 'agent-zoom';
+    d.style.cssText = 'display:none;position:fixed;inset:0;background:rgba(0,0,0,.8);z-index:1400;align-items:center;justify-content:center;cursor:zoom-out';
+    d.onclick = ()=>d.style.display='none';
+    document.body.appendChild(d);
+  }
+  const ovEl = document.getElementById('agent-zoom');
+  ovEl.innerHTML = '';
+  const big = document.createElement('img');
+  big.src = img.src;
+  big.style.cssText = 'max-width:88vw;max-height:88vh;border-radius:8px';
+  ovEl.appendChild(big);
+  ovEl.style.display = 'flex';
+}
+// 截图 img 绑定点击放大
+document.addEventListener('click', ev=>{
+  const t = ev.target;
+  if(t && t.tagName==='IMG' && t.closest('.agent-toolcard') && !t.closest('#agent-zoom')){
+    zoomScreenshot(t);
+  }
+});
+
+function endRun(){
+  setRunning(false);
+  _agentStream && _agentStream.close();
+  _agentStream = null;
+  scrollChat();
+}
+
+// ================== 经验库（自进化记忆管理） ==================
+function openExpLib(){
+  document.getElementById('agent-exp-overlay').style.display = 'flex';
+  loadExpLib();
+}
+function closeExpLib(){
+  document.getElementById('agent-exp-overlay').style.display = 'none';
+}
+function loadExpLib(){
+  const list = document.getElementById('exp-lib-list');
+  apiGet('/api/agent/experience').then(r=>{
+    if(!r||!r.ok){ showToast((r&&r.error)||'加载失败','error'); return; }
+    document.getElementById('exp-lib-last').textContent =
+      (r.last ? ('最近巡检 ' + r.last + '：' + (r.last_summary||'')) : '');
+    if(r.running){
+      list.innerHTML = '<div class="text-muted" style="padding:20px;text-align:center">🔍 AI 巡检进行中（约 1 分钟），完成后请刷新…</div>';
+      return;
+    }
+    const exps = r.experiences||[];
+    if(!exps.length){
+      list.innerHTML = '<div class="text-muted" style="padding:20px;text-align:center">暂无经验——跑一轮带手机操作的任务后会自动沉淀</div>';
+      return;
+    }
+    list.innerHTML = '';
+    exps.forEach(e=>{
+      const a = e.audit||{};
+      const card = document.createElement('div');
+      card.style.cssText = 'border:1px solid var(--card-line);border-radius:10px;padding:9px 13px;background:#0d1117';
+      // 徽章
+      let badge = '';
+      if(a.action === 'pending' && a.verdict === 'delete'){
+        badge = '<span style="background:#7f1d1d;color:#fecaca;font-size:10.5px;padding:1px 8px;border-radius:9px;margin-left:8px">⚠ 建议删除</span>';
+      }else if(a.action === 'kept'){
+        badge = '<span style="background:#0f3d2e;color:#a7f3d0;font-size:10.5px;padding:1px 8px;border-radius:9px;margin-left:8px">' +
+                (a.verdict === 'delete' ? '已人工保留' : '✓ 已保留') + '</span>';
+      }
+      let actBtns = '';
+      if(a.action === 'pending'){
+        actBtns = '<button class="btn btn-xs btn-danger" onclick="expDelete(' + e.id + ')">确认删除</button>'
+                + '<button class="btn btn-xs" onclick="expKeep(' + e.id + ')">保留</button>';
+      }else{
+        actBtns = '<button class="btn btn-xs" style="border-color:#7f1d1d;color:#f87171" onclick="expDelete(' + e.id + ')" title="强制删除此经验">删除</button>';
+      }
+      card.innerHTML =
+        '<div style="display:flex;align-items:center;gap:6px;font-size:12px">'
+        + '<span class="text-muted" style="font-family:var(--mono)">#' + e.id + '</span>'
+        + '<span class="text-muted">' + esc(e.created_at||'') + '</span>'
+        + '<span class="text-muted">引用 ' + (e.hits||0) + ' 次</span>' + badge
+        + '<span style="flex:1"></span>' + actBtns + '</div>'
+        + '<div style="font-size:13px;color:#e5e7eb;margin:5px 0 3px">' + esc(e.task_prompt) + '</div>'
+        + '<div class="text-muted" style="font-size:11.5px;line-height:1.6;white-space:pre-wrap">' + esc((e.recipe||'').slice(0,220)) + '</div>'
+        + (a.action === 'pending' && a.reason
+           ? '<div style="font-size:11.5px;color:#fbbf24;margin-top:5px">AI 建议理由：' + esc(a.reason)
+             + (a.score ? '（评分 ' + a.score + '/10）' : '') + '</div>'
+           : '');
+      list.appendChild(card);
+    });
+  });
+}
+function triggerExpAudit(){
+  apiPost('/api/agent/experience/audit',{}).then(r=>{
+    if(r&&r.ok){
+      showToast('巡检已启动，约 1 分钟完成','success');
+      document.getElementById('exp-lib-list').innerHTML =
+        '<div class="text-muted" style="padding:20px;text-align:center">🔍 AI 巡检进行中…</div>';
+      // 完成后自动刷新
+      setTimeout(()=>{ if(document.getElementById('agent-exp-overlay').style.display==='flex') loadExpLib(); }, 90000);
+    }else showToast((r&&r.error)||'巡检启动失败','error');
+  });
+}
+function expDelete(id){
+  if(!confirm('确认删除该经验？删除后不可恢复（下次相似任务不再自动参考）。')) return;
+  apiPost('/api/agent/experience/delete',{id:id}).then(r=>{
+    if(r&&r.ok){ showToast('已删除','success'); loadExpLib(); }
+    else showToast((r&&r.error)||'删除失败','error');
+  });
+}
+function expKeep(id){
+  apiPost('/api/agent/experience/keep',{id:id}).then(r=>{
+    if(r&&r.ok){ showToast('已保留，后续不再重复建议','success'); loadExpLib(); }
+    else showToast((r&&r.error)||'操作失败','error');
+  });
+}

static/admin/base.js

@@ -94,26 +94,35 @@ function showTab(name){
   // 停止所有定时器
   if(_monitorTimer){clearInterval(_monitorTimer);_monitorTimer=null;}
   if(_logTimer){clearInterval(_logTimer);_logTimer=null;}
+  if(_discoveryTimer){clearInterval(_discoveryTimer);_discoveryTimer=null;}
   // 按需加载数据
   if(name==='monitor'){loadMonitor();_monitorTimer=setInterval(loadMonitor,5000);}
   if(name==='tasks'){showSubTab('tasks',_activeSubs.tasks);loadTasks();loadCustomActions();}
   if(name==='tools'){showSubTab('tools',_activeSubs.tools);loadToolsDevices();loadAdbDevices();loadTailscaleDevices();loadApks();}
-  if(name==='groups')loadGroups();
   if(name==='logs'){loadLogs();if(document.getElementById('log-auto').checked)_logTimer=setInterval(loadLogs,3000);}
+  if(name==='agent' && typeof initAgentChat==='function') initAgentChat();
   if(name==='users')loadUsers();
 }
 
 // ================== 页内子分栏（任务/工具 通用） ==================
 // 每个带子分栏的 Tab 记住上次选中的子分栏，切走再切回来保持原位
 let _activeSubs = {tasks: 'plan', tools: 'clipboard'};
+let _discoveryTimer = null;   // 设备自动发现 10s 轮询（仅 devpool 子分栏激活时）
 
 function showSubTab(tabId, name){
   _activeSubs[tabId] = name;
   const tab = document.getElementById('tab-'+tabId);
   tab.querySelectorAll('.sub-tab').forEach(b=>b.classList.toggle('active', b.dataset.sub===name));
   tab.querySelectorAll('.sub-panel').forEach(p=>p.classList.toggle('active', p.id===tabId+'-sub-'+name));
-  if(name==='screen' && typeof loadScreenDevices==='function') loadScreenDevices();
-  if(name==='devpool' && typeof loadDevPool==='function') loadDevPool();
+  if(name==='groups' && typeof loadGroups==='function') loadGroups();
+  if(name==='devpool' && typeof loadDevPool==='function'){
+    loadDevPool();
+    if(typeof loadDiscovery==='function'){
+      loadDiscovery();
+      if(_discoveryTimer){clearInterval(_discoveryTimer);_discoveryTimer=null;}
+      _discoveryTimer=setInterval(loadDiscovery,10000);   // 10s 轮询：扫完自动出新结果
+    }
+  } else if(_discoveryTimer){clearInterval(_discoveryTimer);_discoveryTimer=null;}
 }
 
 // ================== 模态框 ==================
@@ -133,6 +142,12 @@ function closeModal(){
   }catch(e){console.warn('closeModal cleanup error:',e);}
 }
 
+// 测试此步骤弹窗关闭（editor.js 的测试按钮用；曾随 STF 清理误删）
+function closeTestModal(){
+  const ov=document.getElementById('test-overlay');
+  if(ov)ov.classList.remove('show');
+}
+
 // 关闭元素抓取弹窗（不影响任务编辑窗口）
 function closeElPicker(){
   var ov=document.getElementById('el-picker-overlay');

static/admin/editor.js

@@ -998,6 +998,7 @@ var _stepEditor={
       if(el.description)attrs.push('<span>desc:'+esc(el.description)+'</span>');
       var indent='  '.repeat(Math.min(el.depth||0,6));
       var sg=el.suggested||{};
+      if(sg.invalid)attrs.push('<span style="color:#dc2626">⚠ '+esc(sg.reason||'无可用属性')+'</span>');
       return '<div class="el-picker-item" data-idx="'+idx+'" title="点击填入: '+esc(sg.value||'')+'" onclick="_stepEditor._pickEl('+idx+')">'+
         '<span class="ep-depth">'+(el.depth||0)+'</span>'+
         '<div class="ep-info"><div class="ep-name">'+indent+esc(el.name||el.class||'')+'</div>'+
@@ -1022,6 +1023,10 @@ var _stepEditor={
   _pickEl:function(i){
     var el=this._elData[i];
     if(!el||!this._elTargetInput)return;
+    if(el.suggested&&el.suggested.invalid){
+      showToast(el.suggested.reason||'该元素无法生成选择器','error');
+      return;
+    }
     // 填入推荐选择器值，并切换选择器类型
     this._elTargetInput.value=el.suggested.value;
     var sel=this._elTargetInput.closest('.sc-body').querySelector('[data-key="selector_type"]');
@@ -1077,7 +1082,7 @@ async function saveTask(jobId){
               cron:buildCronFromFreq(),
               stop_cron:(parseInt(st[1])||0)+' '+(parseInt(st[0])||0)+' * * *'};
   }
-  // 运行窗口：窗口外（定时触发 + 手动执行）不启动
+  // 运行窗口：只约束定时触发（窗口外定时不启动），手动执行不受限制
   if(document.getElementById('f-window_enable').checked){
     schedule.window={
       start:document.getElementById('f-window_start').value||'09:00',

static/admin/monitor.js

@@ -307,8 +307,14 @@ function renderDevices(){
   if(_sig===_devicesSig)return;
   _devicesSig=_sig;
   // 排序由 applyListPager 统一处理（sortValue + _lpSort）
+  // 「只看在线」勾选时过滤离线设备（默认勾选）
+  const onlyOnline=document.getElementById('monitor-filter-online')
+    ? document.getElementById('monitor-filter-online').checked : true;
   setListPager('devices',{
-    data:()=>_statusData.devices||[],
+    data:()=>{
+      const all=_statusData.devices||[];
+      return onlyOnline? all.filter(d=>d.present) : all;
+    },
     filter:(dev,kw)=>((dev.serial||'').toLowerCase().includes(kw)||(dev.model||'').toLowerCase().includes(kw)||(dev.foreground_app||'').toLowerCase().includes(kw)||(dev.task_job||'').toLowerCase().includes(kw)||(dev.current_action||'').toLowerCase().includes(kw)),
     sortValue:_sortValue,
     render:renderDeviceRow,

static/admin/tasks.js

@@ -141,7 +141,7 @@ function openTaskModal(jobId){
       '<div class="form-group"><label>允许运行·开始</label><input type="time" class="form-control" id="f-window_start" value="'+esc(winStart)+'"></div>'+
       '<div class="form-group"><label>允许运行·结束</label><input type="time" class="form-control" id="f-window_end" value="'+esc(winEnd)+'"></div>'+
     '</div>'+
-    '<div class="help" id="f-window_help" style="display:'+(win?'block':'none')+'">窗口外任务不会启动（定时触发和手动执行都受约束）。跨午夜示例：21:00-09:00 = 晚 9 点到次日早 9 点允许运行</div>'+
+    '<div class="help" id="f-window_help" style="display:'+(win?'block':'none')+'">窗口只约束定时触发：窗口外定时不会启动，手动执行不受限制。跨午夜示例：21:00-09:00 = 晚 9 点到次日早 9 点允许运行</div>'+
     '<div class="form-row">'+
       '<div class="form-group"><label>重试次数</label><input type="number" class="form-control" id="f-retry_attempts" value="'+j.retry.max_attempts+'" min="1" max="10"></div>'+
       '<div class="form-group"><label>重试间隔(秒)</label><input type="number" class="form-control" id="f-retry_delay" value="'+j.retry.delay+'" min="10" max="3600"></div>'+

static/admin/tools.js

@@ -21,7 +21,9 @@ async function loadToolsDevices(force){
   const list = await _fetchAdbDevices(force);
   const status = document.getElementById('clip-status');
   if(list === null){status.textContent='加载失败';showToast('加载设备失败','error');return;}
-  _clipDevices = list;
+  // 剪贴板注入只对在线设备有意义：过滤掉设备池未连接(pool)/离线条目；
+  // adb 终端面板保留全部（重连设备需要），它用自己的渲染逻辑不受影响
+  _clipDevices = list.filter(d=>d.state==='device');
   const wrap = document.getElementById('clip-devices');
   if(!_clipDevices.length){
     wrap.innerHTML='<div class="empty" style="padding:20px">无可用设备（本地 adb 或设备池均无）</div>';
@@ -39,11 +41,142 @@ async function loadToolsDevices(force){
   status.textContent = '共 '+_clipDevices.length+' 台设备';
 }
 
+// ================== 设备自动发现（扫描 → 待连接池 → 确认） ==================
+function loadDiscovery(){
+  apiGet('/api/devices/discovery').then(r=>{
+    if(!r||!r.ok)return;
+    const status=document.getElementById('discovery-status');
+    const enabled=document.getElementById('discovery-enabled');
+    const interval=document.getElementById('discovery-interval');
+    const subnets=document.getElementById('discovery-subnets');
+    if(!enabled)return;   // 面板未渲染（离开子分栏）
+    enabled.checked=!!r.enabled;
+    interval.value=r.interval||60;
+    subnets.value=(r.subnets||[]).join(', ');
+    // 状态行
+    if(r.scanning){status.textContent='扫描中...';}
+    else if(r.last_scan){
+      let txt='上次扫描 '+esc(r.last_scan)+' · 开放 '+r.last_result.found+' · 可连 '
+        +(r.last_result.verified||0)+' · 新增 '+(r.last_result.new||0);
+      if(r.last_error)txt+=' · ⚠ '+esc(r.last_error);
+      status.textContent=txt;
+    }else{status.textContent='尚未扫描';}
+    // 待连接表格：只显示在线设备（离线候选不可确认连接，隐藏；恢复在线后自动出现）
+    const rows=(r.pending||[]).filter(x=>x.online);
+    const tb=document.getElementById('tb-discovery');
+    if(!tb)return;
+    if(!rows.length){
+      tb.innerHTML='<tr><td colspan="6" class="empty">待连接池为空（扫描到的设备会出现在这里）</td></tr>';
+    }else{
+      tb.innerHTML=rows.map(x=>{
+        const src=x.source==='tailscale'
+          ?'<span class="label label-info">Tailscale</span>'
+          :'<span class="label label-warning">局域网</span>';
+        const onl=x.online
+          ?'<span class="label label-success">在线</span>'
+          :'<span class="label label-warning">离线</span>';
+        return '<tr><td style="font-family:monospace">'+esc(x.serial)+'</td>'
+          +'<td>'+src+'</td><td>'+esc(x.first_seen)+'</td><td>'+esc(x.last_seen)+'</td><td>'+onl+'</td>'
+          +'<td><button class="btn btn-primary btn-xs" data-serial="'+esc(x.serial)+'" onclick="confirmDiscoveryDev(this.dataset.serial)">确认添加</button> '
+          +'<button class="btn btn-xs" data-serial="'+esc(x.serial)+'" onclick="ignoreDiscoveryDev(this.dataset.serial)">忽略</button></td></tr>';
+      }).join('');
+    }
+    // 正式池断联设备：仍在设备池（不删除），扫描线程自动重连，可手动立即重连
+    const offTb=document.getElementById('tb-pool-offline');
+    if(offTb){
+      const off=(r.pool_offline||[]);
+      if(!off.length){
+        offTb.innerHTML='<tr><td colspan="5" class="empty">全部在线</td></tr>';
+      }else{
+        offTb.innerHTML=off.map(x=>{
+          return '<tr><td style="font-family:monospace">'+esc(x.serial)+'</td>'
+            +'<td>'+esc(x.model||'-')+'</td><td>'+esc(x.name||'')+'</td>'
+            +'<td><span class="label label-danger">断联·自动重连中</span></td>'
+            +'<td><button class="btn btn-xs" data-serial="'+esc(x.serial)+'" onclick="reconnectPoolDev(this.dataset.serial)">立即重连</button></td></tr>';
+        }).join('');
+      }
+    }
+  });
+}
+function reconnectPoolDev(serial){
+  apiPost('/api/devices/discovery/reconnect',{serial}).then(r=>{
+    if(r&&r.ok){
+      showToast('重连已启动（约 5-15 秒生效）','success');
+      setTimeout(loadDiscovery,8000);
+    }else showToast('重连失败: '+((r&&r.error)||''),'error');
+  });
+}
+function toggleDiscovery(checked){
+  apiPost('/api/devices/discovery/settings',{enabled:checked}).then(r=>{
+    if(r&&r.ok)showToast('定时扫描已'+(checked?'开启':'关闭'),'success');
+    else showToast('设置失败: '+((r&&r.error)||''),'error');
+  });
+}
+function saveDiscoverySettings(){
+  const subnets=(document.getElementById('discovery-subnets').value||'')
+    .split(',').map(s=>s.trim()).filter(Boolean);
+  const interval=parseInt(document.getElementById('discovery-interval').value)||60;
+  apiPost('/api/devices/discovery/settings',{subnets,interval}).then(r=>{
+    if(r&&r.ok)showToast('设置已保存','success');
+    else showToast('保存失败: '+((r&&r.error)||''),'error');
+  });
+}
+function runDiscoveryScan(){
+  apiPost('/api/devices/discovery/scan',{}).then(r=>{
+    if(r&&r.ok){showToast(r.msg||'扫描已启动','success');setTimeout(loadDiscovery,3000);}
+    else showToast('扫描失败: '+((r&&r.error)||''),'error');
+  });
+}
+function confirmDiscoveryDev(serial){
+  const name=prompt('备注名（可选，留空直接添加）','');
+  if(name===null)return;
+  apiPost('/api/devices/discovery/confirm',{serial,name}).then(r=>{
+    if(r&&r.ok){
+      showToast('已加入设备池'+(r.is_new?'':'（已存在，已更新）'),'success');
+      loadDevPool();loadDiscovery();
+    }else showToast('确认失败: '+((r&&r.error)||''),'error');
+  });
+}
+function ignoreDiscoveryDev(serial){
+  if(!confirm('忽略 '+serial+'？下轮扫描可能再次发现'))return;
+  apiPost('/api/devices/discovery/ignore',{serial}).then(r=>{
+    if(r&&r.ok){showToast('已忽略','success');loadDiscovery();}
+    else showToast('操作失败: '+((r&&r.error)||''),'error');
+  });
+}
+
 function toggleClipDevice(cb){
   if(cb.checked)_clipSelected.add(cb.value);
   else _clipSelected.delete(cb.value);
 }
 
+// 注入剪贴板（ClipInject APK 通道，Android 10+ 可用）：
+// am start 透明 Activity 写入 + u2 读回比对验证；结果逐台渲染 + toast 汇总
+function injectClipboard(){
+  const text = document.getElementById('clip-text').value;
+  const serials = [..._clipSelected];
+  if(!serials.length){showToast('请先勾选目标设备','error');return;}
+  if(!text.trim()){showToast('请输入注入内容','error');return;}
+  const btn = Array.from(document.querySelectorAll('#tools-sub-clipboard .btn-primary'))
+    .find(b=>b.textContent.includes('注入剪贴板'));
+  if(btn){btn.disabled = true; const old = btn.textContent; btn.textContent = '注入中...'; btn._old = old;}
+  apiPost('/api/tools/clipboard/set', {serials, text}).then(r=>{
+    if(!r){showToast('请求失败','error');return;}
+    const rows = Object.entries(r.results||{}).map(([s,v])=>{
+      const ok = !!v.ok;
+      return '<tr><td style="font-family:monospace">'+esc(s)+'</td>'
+        +'<td><span class="label '+(ok?'label-success':'label-danger')+'">'
+        +(ok?'成功':'失败')+'</span> '+esc(v.msg||'')+'</td></tr>';
+    }).join('');
+    document.getElementById('clip-result').innerHTML = rows;
+    document.getElementById('clip-result-wrap').style.display='block';
+    const okc = r.ok_count||0, fail = r.fail_count||0;
+    if(fail>0) showToast(okc+' 台成功，'+fail+' 台失败','error');
+    else showToast(okc+' 台设备注入成功','success');
+  }).catch(e=>{showToast('注入异常: '+e,'error');})
+  .finally(()=>{ if(btn){btn.disabled=false; btn.textContent=btn._old;} });
+}
+
 // ================== 工具：应用版本管理 ==================
 let _appVerRows = [];            // [{serial, installed, version_name, version_code, error}]
 
@@ -277,127 +410,6 @@ function copyTsKey(){
 }
 
 
-// ================== Tab: 工具 - 远程看屏（MJPEG 流 + u2 触控） ==================
-let _screenViewOn = false;
-
-async function loadScreenDevices(force){
-  const sel=document.getElementById('screen-device');
-  if(!sel)return;
-  const list=await _fetchAdbDevices(force);
-  if(list===null)return;
-  const cur=sel.value;
-  const stateTxt={device:'在线',offline:'离线',pool:'设备池(未连接)'};
-  sel.innerHTML=list.map(d=>
-    '<option value="'+esc(d.serial)+'">'+esc(d.serial)+' ('+(stateTxt[d.state]||d.state)+')</option>'
-  ).join('');
-  if(cur)sel.value=cur;
-}
-
-function _screenSerial(){
-  const sel=document.getElementById('screen-device');
-  return sel?sel.value:'';
-}
-
-function startScreenView(){
-  const serial=_screenSerial();
-  if(!serial){showToast('请先选择设备','error');return;}
-  stopScreenView();
-  const img=document.getElementById('screen-img');
-  const loading=document.getElementById('screen-loading');
-  loading.style.display='flex';
-  document.getElementById('screen-status').textContent='';
-  img.src='/api/screen/stream?serial='+encodeURIComponent(serial);
-  img.onload=()=>{loading.style.display='none';_screenViewOn=true;document.getElementById('screen-status').textContent='观看中';};
-  img.onerror=()=>{loading.style.display='none';_screenViewOn=false;showToast('画面流中断（设备离线或已停止）','error');};
-}
-
-function stopScreenView(){
-  const img=document.getElementById('screen-img');
-  if(img)img.src='';
-  _screenViewOn=false;
-  const loading=document.getElementById('screen-loading');
-  if(loading)loading.style.display='none';
-  const st=document.getElementById('screen-status');
-  if(st)st.textContent='';
-}
-
-// 显示尺寸 -> 设备原生分辨率（img.naturalWidth/Height 即设备分辨率）
-function _screenCoords(ev){
-  const img=document.getElementById('screen-img');
-  if(!img.naturalWidth)return [null,null];
-  const r=img.getBoundingClientRect();
-  return [
-    Math.round((ev.clientX-r.left)/r.width*img.naturalWidth),
-    Math.round((ev.clientY-r.top)/r.height*img.naturalHeight),
-  ];
-}
-
-function _screenTap(x,y){
-  const serial=_screenSerial();
-  if(!serial||x==null||y==null)return;
-  apiPost('/api/screen/tap',{serial,x,y}).then(r=>{if(r&&!r.ok)showToast(r.error,'error');});
-}
-
-function _screenSwipe(x1,y1,x2,y2){
-  const serial=_screenSerial();
-  if(!serial||x1==null)return;
-  apiPost('/api/screen/swipe',{serial,x1,y1,x2,y2}).then(r=>{if(r&&!r.ok)showToast(r.error,'error');});
-}
-
-function screenKey(key){
-  const serial=_screenSerial();
-  if(!serial){showToast('请先选择设备','error');return;}
-  apiPost('/api/screen/key',{serial,key}).then(r=>{if(r&&!r.ok)showToast(r.error,'error');});
-}
-
-function screenSendText(){
-  const serial=_screenSerial();
-  const inp=document.getElementById('screen-text');
-  const text=(inp.value||'').trim();
-  if(!serial){showToast('请先选择设备','error');return;}
-  if(!text){showToast('请输入文字','error');return;}
-  apiPost('/api/screen/text',{serial,text}).then(r=>{
-    if(r&&!r.ok)showToast(r.error,'error');
-    else inp.value='';
-  });
-}
-
-// 鼠标 + 触控：拖拽=滑动，点按=轻触
-(function(){
-  const img=document.getElementById('screen-img');
-  if(!img)return;
-  let dragging=false, sx=0, sy=0;
-
-  function onDown(ev){
-    if(!_screenViewOn)return;
-    ev.preventDefault();
-    dragging=true;
-    const [x,y]=_screenCoords(ev);
-    sx=x; sy=y;
-  }
-  function onUp(ev){
-    if(!dragging)return;
-    dragging=false;
-    const [x,y]=_screenCoords(ev);
-    if(x==null)return;
-    if(Math.abs(x-sx)<8 && Math.abs(y-sy)<8){
-      _screenTap(x,y);            // 位移小 → 点击
-    }else{
-      _screenSwipe(sx,sy,x,y);    // 有位移 → 滑动
-    }
-  }
-
-  img.addEventListener('mousedown',onDown);
-  img.addEventListener('mousemove',ev=>{if(dragging)ev.preventDefault();});
-  window.addEventListener('mouseup',onUp);
-  img.addEventListener('touchstart',onDown,{passive:false});
-  img.addEventListener('touchend',ev=>{
-    if(!dragging)return;
-    const t=ev.changedTouches[0];
-    onUp({clientX:t.clientX,clientY:t.clientY,preventDefault(){}});
-  },{passive:false});
-})();
-
 // ================== Tab: 工具 - 设备池管理（本地 SQLite 清单） ==================
 async function loadDevPool(){
   const tb=document.getElementById('tb-devpool');
@@ -406,9 +418,16 @@ async function loadDevPool(){
   tb.innerHTML='<tr><td colspan="7" class="empty">加载中...</td></tr>';
   const r=await apiGet('/api/devices/pool');
   if(!r||!r.ok){tb.innerHTML='<tr><td colspan="7" class="empty">加载失败</td></tr>';return;}
-  const rows=r.devices||[];
+  let rows=r.devices||[];
+  // 在线优先排序；「只看在线」勾选时过滤掉离线（IP 换了/长期离线的旧条目不再碍眼）
+  const onlyOnline=document.getElementById('devpool-filter-online')
+    ? document.getElementById('devpool-filter-online').checked : false;
+  rows.sort((a,b)=>(b.online?1:0)-(a.online?1:0));
+  if(onlyOnline)rows=rows.filter(x=>x.online);
   const onlineCnt=rows.filter(x=>x.online).length;
-  status.textContent='共 '+rows.length+' 台，在线 '+onlineCnt+' 台';
+  status.textContent=onlyOnline
+    ? '在线 '+rows.length+' 台（共 '+(r.devices||[]).length+' 台配置）'
+    : '共 '+rows.length+' 台，在线 '+onlineCnt+' 台';
   tb.innerHTML=rows.map(d=>{
     const st= d.enabled
       ? '<span class="label label-success">启用</span>'

tasks/generic/task.py

@@ -478,26 +478,37 @@ class GenericStepsWorker(BaseWorker):
         return found  # 命中结果，"测试此步骤"用
 
     def _exec_clipboard(self, d, params, depth=0):
-        """剪贴板注入：写入指定内容到剪贴板，可选立即粘贴到当前聚焦的输入框。
+        """剪贴板注入（ClipInject 通道，Android 10+ 可用），可选立即粘贴。
 
         批量发链接场景：先聚焦评论区输入框 → 注入+粘贴链接1 → 换链接 → 注入+粘贴链接2……
-        粘贴模式复用 u2 send_keys（内部 setClipboard + pasteClipboard，与"输入文字"同机制）。
+        粘贴模式：ClipInject 写入剪贴板后调 atx-agent pasteClipboard 粘贴到当前
+        焦点输入框；动作失败时兜底 u2 set_text 直接设置聚焦输入框文本（不依赖
+        剪贴板，与"输入文字"兜底同机制）。
         """
         text = str(params.get("text", "") or "")
         if not text:
             _log.warning(f"[{self.serial}] clipboard 内容为空，跳过")
             return False
+        from core.clipboard_helper import inject_clipboard
+        ok, msg = inject_clipboard(self.serial, text, d=d)
+        if not ok:
+            _log.warning(f"[{self.serial}] 剪贴板注入失败: {msg}")
+            return False
+        _log.info(f"[{self.serial}] 剪贴板注入: {text[:60]}（{msg}）")
+        if not params.get("paste"):
+            return True
         try:
-            if params.get("paste"):
-                d.send_keys(text)  # setClipboard + pasteClipboard
-                _log.info(f"[{self.serial}] 剪贴板注入并粘贴: {text[:60]}")
-            else:
-                d.set_clipboard(text)
-                _log.info(f"[{self.serial}] 剪贴板注入(不粘贴): {text[:60]}")
+            d.jsonrpc.pasteClipboard()
+            _log.info(f"[{self.serial}] 已粘贴: {text[:60]}")
             return True
         except Exception as e:
-            _log.warning(f"[{self.serial}] 剪贴板注入异常: {e}")
-            return False
+            try:
+                d(focused=True).set_text(text)
+                _log.info(f"[{self.serial}] 粘贴兜底 set_text: {text[:60]}")
+                return True
+            except Exception as e2:
+                _log.warning(f"[{self.serial}] 粘贴失败: {e} / {e2}")
+                return True  # 剪贴板已写入，粘贴失败不致命
 
     def _exec_wait(self, d, params, depth=0):
         min_s = float(params.get("min", 1.0))
@@ -645,7 +656,7 @@ def test_step(serial, step):
     if d is None:
         return False, "u2 连接超时", None
     try:
-        w = GenericStepsWorker(None, serial, {})
+        w = GenericStepsWorker(serial, {})
         result = w._exec_one(d, step)
         return True, f"步骤已执行（{step.get('label') or step.get('type')}）", result
     except Exception as e:

templates/admin/monitor.html

@@ -303,6 +303,54 @@ body{background:var(--bg);font-family:var(--body);color:var(--text);font-size:14
 .el-picker-item .ep-info .ep-attrs{color:var(--text-light);font-size:11px;margin-top:2px;word-break:break-all}
 .el-picker-item .ep-info .ep-attrs span{margin-right:8px}
 .el-picker-item .ep-sel{font-size:10px;color:#fff;background:var(--primary);padding:1px 7px;border-radius:99px;flex-shrink:0;font-weight:600}
+
+/* ===== AI 控制台（聊天界面，浅色内容区——DeepSeek 风格，图片文字清晰） ===== */
+.agent-body{display:flex;flex:1;min-height:0}
+.agent-col-sessions{width:236px;border-right:1px solid #e5e7eb;background:#f6f7f9;display:flex;flex-direction:column;min-width:0}
+.agent-sess-head{padding:10px;border-bottom:1px solid #e5e7eb}
+.agent-sess-list{flex:1;overflow-y:auto;padding:6px}
+.agent-sess-item{padding:8px 10px;border-radius:9px;cursor:pointer;margin-bottom:2px;border:1px solid transparent;position:relative}
+.agent-sess-item:hover{background:#eceff3}
+.agent-sess-item.active{background:#e0f2fe;border-color:#bae6fd}
+.agent-sess-item .t{font-size:12.5px;color:#1f2937;white-space:nowrap;overflow:hidden;text-overflow:ellipsis;padding-right:20px}
+.agent-sess-item .m{font-size:10.5px;color:#9ca3af;margin-top:2px}
+.agent-sess-del{position:absolute;right:6px;top:6px;visibility:hidden;background:transparent;border:none;color:#9ca3af;cursor:pointer;font-size:12px;padding:2px 5px;border-radius:5px}
+.agent-sess-item:hover .agent-sess-del{visibility:visible}
+.agent-sess-del:hover{background:#fecaca;color:#b91c1c}
+.agent-col-chat{flex:1;display:flex;flex-direction:column;min-width:0}
+.agent-col-live{width:300px;border-left:1px solid #e5e7eb;background:#fff;display:flex;flex-direction:column;padding:10px}
+.agent-live-head{font-size:12.5px;font-weight:600;color:#374151;display:flex;align-items:center;justify-content:space-between;margin-bottom:8px}
+.agent-live-serial{font-family:var(--mono);font-size:10.5px;color:#6b7280}
+.agent-live-body{flex:1;background:#0b0f14;border-radius:10px;display:flex;align-items:center;justify-content:center;overflow:hidden;min-height:200px}
+.agent-live-body img{width:100%;height:100%;object-fit:contain}
+.agent-live-body .agent-empty{color:#4b5563;padding:20px;font-size:12px;line-height:1.8}
+.agent-shell{display:flex;flex-direction:column;height:calc(100vh - 150px);min-height:520px;border:1px solid #e5e7eb;border-radius:14px;overflow:hidden;background:#fff}
+.agent-shell{display:flex;flex-direction:column;height:calc(100vh - 150px);min-height:480px;border:1px solid #e5e7eb;border-radius:14px;overflow:hidden;background:#fff}
+.agent-topbar{display:flex;align-items:center;justify-content:space-between;padding:10px 16px;border-bottom:1px solid #e5e7eb;background:#f9fafb}
+.agent-title{font-size:14px;font-weight:700;color:#111827}
+.agent-model-tag{margin-left:8px;font-size:11px;color:#0e7490;font-family:var(--mono);background:#e0f2fe;padding:2px 8px;border-radius:10px}
+.agent-running-tag{color:#dc2626;font-size:12px;margin-right:8px}
+.agent-top-actions{display:flex;align-items:center;gap:6px}
+.agent-top-actions .btn{background:#fff;border:1px solid #d1d5db;color:#374151}
+.agent-top-actions .btn:hover{border-color:#0e7490;color:#0e7490}
+.agent-chat{flex:1;overflow-y:auto;padding:20px 26px;display:flex;flex-direction:column;gap:16px;background:#f7f8fa}
+.agent-msg{max-width:80%;padding:11px 15px;border-radius:13px;font-size:13.5px;line-height:1.7;white-space:pre-wrap;word-break:break-word}
+.agent-msg.user{align-self:flex-end;background:#0e7490;color:#fff;border-bottom-right-radius:3px}
+.agent-msg.assistant{align-self:flex-start;background:#fff;border:1px solid #e5e7eb;border-bottom-left-radius:3px;color:#1f2937;box-shadow:0 1px 2px rgba(0,0,0,.04)}
+.agent-msg.assistant .reasoning{color:#6b7280;font-size:12.5px;border-left:3px solid #d1d5db;padding-left:10px;margin:8px 0}
+.agent-toolcards{display:flex;flex-direction:column;gap:5px;margin-bottom:9px}
+.agent-toolcard{display:flex;align-items:flex-start;gap:8px;background:#f3f4f6;border:1px solid #e5e7eb;border-radius:9px;padding:6px 11px;font-size:12px;font-family:var(--mono);color:#374151;flex-wrap:wrap}
+.agent-toolcard .dot{width:7px;height:7px;border-radius:50%;background:#10b981;flex:none;margin-top:5px}
+.agent-toolcard code{color:#0e7490}
+.agent-toolcard .text-muted{color:#6b7280}
+.agent-toolcard img{max-width:190px;border-radius:7px;margin-top:4px;border:1px solid #e5e7eb;display:block;cursor:zoom-in}
+.agent-inputbar{display:flex;gap:10px;padding:12px 14px;border-top:1px solid #e5e7eb;background:#fff}
+.agent-inputbar textarea{flex:1;resize:none;background:#f9fafb;border:1px solid #d1d5db;border-radius:10px;padding:9px 12px;color:#111827;font-size:13.5px;outline:none;line-height:1.5}
+.agent-inputbar textarea:focus{border-color:#0e7490;box-shadow:0 0 0 2px rgba(14,116,144,.12)}
+.agent-inputbar .btn-primary{background:#0e7490;border:none}
+.agent-inputbar .btn-primary:hover{background:#155e75}
+.agent-inputbar .btn-primary:disabled{background:#9ca3af}
+.agent-empty{color:#6b7280;font-size:13px;text-align:center;padding:44px 0}
 </style>
 </head>
 <body>
@@ -313,13 +361,14 @@ body{background:var(--bg);font-family:var(--body);color:var(--text);font-size:14
   <div class="tabs">
     <button class="tab active" data-tab="monitor" onclick="showTab('monitor')">监控</button>
     <button class="tab" data-tab="tasks" onclick="showTab('tasks')">任务</button>
-    <button class="tab" data-tab="groups" onclick="showTab('groups')">分组</button>
     <button class="tab" data-tab="logs" onclick="showTab('logs')" data-perm="logs">日志</button>
     <button class="tab" data-tab="users" onclick="showTab('users')" data-perm="admin">用户</button>
     <button class="tab" data-tab="tools" onclick="showTab('tools')" data-perm="admin">工具</button>
+    <button class="tab" data-tab="agent" onclick="showTab('agent')" data-perm="admin">AI 控制台</button>
   </div>
   <div class="user-info">
     <span id="me-username">...</span>
+    <a href="/wall" target="_blank" title="监控大屏（全屏，挂墙/电视用）">📺 大屏</a>
     <a href="/logout">退出</a>
   </div>
 </nav>
@@ -342,6 +391,9 @@ body{background:var(--bg);font-family:var(--body);color:var(--text);font-size:14
     <button class="btn" onclick="screenAllDevices('on')" data-perm="devices" title="所有在线设备亮屏并解锁">一键亮屏</button>
     <button class="btn" onclick="screenAllDevices('off')" data-perm="devices" title="所有在线设备息屏（运行中任务会中断）">一键息屏</button>
     <button class="btn" onclick="loadMonitor()">刷新</button>
+    <label style="display:inline-flex;align-items:center;gap:4px;margin:0 6px">
+      <input type="checkbox" id="monitor-filter-online" checked onchange="loadMonitor()"> 只看在线
+    </label>
     <input class="form-control list-search" id="search-devices" placeholder="搜索设备/型号/App/任务...">
     <span class="hint"><span id="fg-status"></span> · 每 5 秒自动刷新 · <span id="srvTime"></span> · <span id="sel-count">未选中</span></span>
   </div>
@@ -419,21 +471,95 @@ body{background:var(--bg);font-family:var(--body);color:var(--text);font-size:14
 </div>
 
 <!-- ========== Tab 3: 分组 ========== -->
-<div id="tab-groups" class="tab-panel">
-  <div class="page-title">设备分组管理</div>
-  <div class="page-sub">管理设备分组，用于任务按分组执行</div>
-  <div class="toolbar">
-    <button class="btn btn-primary" onclick="openGroupModal()" data-perm="tasks">新建分组</button>
-    <button class="btn" onclick="loadGroups()">刷新</button>
-    <input class="form-control list-search" id="search-groups" placeholder="搜索分组名/描述...">
+<!-- ========== Tab: AI 控制台（DeepSeek 风格聊天 + 实时 MCP 步骤） ========== -->
+<div id="tab-agent" class="tab-panel">
+  <div class="agent-shell">
+    <div class="agent-topbar">
+      <div class="agent-title">🤖 AI 控制台<span id="agent-model-tag" class="agent-model-tag"></span></div>
+      <div class="agent-top-actions">
+        <span id="agent-running-tag" class="agent-running-tag" style="display:none">● 运行中</span>
+        <button class="btn btn-xs" onclick="openExpLib()" title="查看/管理自进化经验库（每日 AI 巡检建议，删除需确认）">🧠 经验库</button>
+        <button class="btn btn-xs" onclick="openAgentConfig()">⚙ 配置</button>
+      </div>
+    </div>
+    <div class="agent-body">
+      <div class="agent-col-sessions">
+        <div class="agent-sess-head">
+          <button class="btn btn-primary" style="width:100%" onclick="createAgentSession()">＋ 新建会话</button>
+        </div>
+        <div id="agent-sess-list" class="agent-sess-list"></div>
+      </div>
+      <div class="agent-col-chat">
+        <div id="agent-chat" class="agent-chat"></div>
+      </div>
+      <div class="agent-col-live">
+        <div class="agent-live-head">📺 实时画面<span id="agent-live-serial" class="agent-live-serial"></span></div>
+        <div class="agent-live-body" id="agent-live-body">
+          <img id="agent-live-img" alt="" style="display:none;width:100%">
+          <div class="agent-empty" id="agent-live-empty">运行任务时自动跟随操作的设备；<br>也可手动选择设备观看</div>
+        </div>
+        <select id="agent-live-select" class="form-control" style="margin-top:8px"
+                onchange="watchDevice(this.value)"><option value="">选择设备观看…</option></select>
+      </div>
+    </div>
+    <div class="agent-inputbar" style="align-items:flex-end;flex-direction:column">
+      <div style="display:flex;width:100%;gap:8px;align-items:center;margin-bottom:8px">
+        <label style="font-size:12.5px;color:#374151;font-weight:600;white-space:nowrap">🎯 目标设备</label>
+        <select id="agent-target-select" class="form-control" style="width:320px;font-family:monospace"
+                title="AI 只操作你选定的设备；有任务运行中的设备不可选">
+          <option value="">请选择设备（AI 只操作选定设备）…</option>
+        </select>
+        <span class="text-muted" id="agent-target-hint" style="font-size:11.5px"></span>
+        <span style="flex:1"></span>
+        <button class="btn btn-xs btn-danger" id="btn-agent-stop" style="display:none" onclick="stopAgent()">■ 停止</button>
+      </div>
+      <div style="display:flex;width:100%;gap:10px">
+        <textarea id="agent-input" rows="2"
+                  placeholder="给 AI 下达指令，例如：打开抖音搜索奚学东，把第一个视频标题告诉我…（Enter 发送，Shift+Enter 换行）"></textarea>
+        <button class="btn btn-primary" id="btn-agent-send" onclick="sendAgentMsg()">发送</button>
+      </div>
+    </div>
+  </div>
+</div>
+
+<!-- ========== 配置模态框 ========== -->
+<div id="agent-cfg-overlay" style="display:none;position:fixed;inset:0;background:rgba(0,0,0,.6);z-index:1300;align-items:center;justify-content:center">
+  <div style="background:#11151c;border:1px solid var(--card-line);border-radius:14px;padding:22px;width:460px;max-width:92vw">
+    <div style="font-size:15px;font-weight:700;margin-bottom:14px">模型配置（OpenAI 兼容 API）</div>
+    <div class="form-group"><label>API Base</label>
+      <input type="text" id="acfg-base" class="form-control" placeholder="https://api.deepseek.com" style="font-family:monospace"></div>
+    <div class="form-group"><label>模型名</label>
+      <input type="text" id="acfg-model" class="form-control" placeholder="deepseek-v4-flash-vision-exp"></div>
+    <div class="form-group"><label>API Key <span class="text-muted" id="acfg-key-hint"></span></label>
+      <input type="password" id="acfg-key" class="form-control" placeholder="留空则不修改"></div>
+    <div class="form-group"><label>默认设备 serial（可选）</label>
+      <input type="text" id="acfg-serial" class="form-control" placeholder="192.168.20.66:5555" style="font-family:monospace"></div>
+    <div class="form-group"><label>最大执行步骤（1-200，默认 40）</label>
+      <input type="number" id="acfg-steps" class="form-control" min="1" max="200" placeholder="40"
+             title="单轮任务允许的最大工具调用轮数；超限会收尾总结（防死循环）"></div>
+    <div style="display:flex;justify-content:flex-end;gap:8px;margin-top:6px">
+      <button class="btn" onclick="closeAgentConfig()">取消</button>
+      <button class="btn btn-primary" onclick="saveAgentConfig()">保存</button>
+    </div>
+  </div>
+</div>
+
+<!-- ========== 经验库模态框（自进化记忆管理 + 每日 AI 巡检建议） ========== -->
+<div id="agent-exp-overlay" style="display:none;position:fixed;inset:0;background:rgba(0,0,0,.6);z-index:1320;align-items:center;justify-content:center">
+  <div style="background:#11151c;border:1px solid var(--card-line);border-radius:14px;padding:20px 22px;width:760px;max-width:94vw;max-height:86vh;display:flex;flex-direction:column">
+    <div style="display:flex;align-items:center;justify-content:space-between;margin-bottom:4px">
+      <div style="font-size:15px;font-weight:700">🧠 经验库<span class="text-muted" style="font-size:11.5px;font-weight:400;margin-left:8px" id="exp-lib-hint"></span></div>
+      <div style="display:flex;gap:6px;align-items:center">
+        <button class="btn btn-xs" onclick="triggerExpAudit()">🔍 立即巡检</button>
+        <button class="btn btn-xs" onclick="closeExpLib()">✕ 关闭</button>
+      </div>
+    </div>
+    <div class="text-muted" style="font-size:11.5px;padding:0 2px 8px;border-bottom:1px solid var(--card-line);margin-bottom:10px">
+      每次任务成功后会提炼「操作配方」存入经验库，下次相似任务自动参考；每日 03:47 AI 巡检给出疑似问题建议（删除需人工确认）。
+      <span id="exp-lib-last" class="text-muted"></span>
+    </div>
+    <div id="exp-lib-list" style="flex:1;overflow-y:auto;min-height:200px;display:flex;flex-direction:column;gap:8px"></div>
   </div>
-  <table class="table">
-    <thead><tr>
-      <th data-sort="name" onclick="_lpSort('groups','name')">分组名</th><th>描述</th><th data-sort="count" onclick="_lpSort('groups','count')">设备数</th><th>设备列表</th><th>操作</th>
-    </tr></thead>
-    <tbody id="tb-groups"></tbody>
-  </table>
-  <div class="list-pager" id="pager-groups"></div>
 </div>
 
 <!-- ========== Tab 4: 日志 ========== -->
@@ -493,7 +619,7 @@ body{background:var(--bg);font-family:var(--body);color:var(--text);font-size:14
     <button class="sub-tab" data-sub="appver" onclick="showSubTab('tools','appver')">应用版本管理</button>
     <button class="sub-tab" data-sub="devapps" onclick="showSubTab('tools','devapps')">设备已装应用</button>
     <button class="sub-tab" data-sub="devpool" onclick="showSubTab('tools','devpool')">设备池管理</button>
-    <button class="sub-tab" data-sub="screen" onclick="showSubTab('tools','screen')">远程看屏</button>
+    <button class="sub-tab" data-sub="groups" onclick="showSubTab('tools','groups')">设备分组</button>
   </div>
 
   <!-- 子分栏 1：剪贴板注入 -->
@@ -513,7 +639,7 @@ body{background:var(--bg);font-family:var(--body);color:var(--text);font-size:14
           <button class="btn btn-primary" onclick="injectClipboard()">注入剪贴板</button>
           <span class="hint">注入后需在目标 App 的输入框长按选择"粘贴"</span>
         </div>
-        <div class="help">实现：u2 setClipboard（jsonrpc 直连 atx-agent），实测支持中文、引号、换行；USB 设备首次连接会自动推送 atx-agent。</div>
+        <div class="help">实现：ClipInject APK 透明 Activity 写入剪贴板（Android 10+ 可用，u2 setClipboard 在 Android 12/13 会被系统丢弃）；设备需先安装 com.example.clipinject，注入后自动读回比对验证。</div>
       </div>
       <div style="flex:1;min-width:280px">
         <div class="form-group">
@@ -649,6 +775,37 @@ body{background:var(--bg);font-family:var(--body);color:var(--text);font-size:14
 
   <!-- 子分栏 6：设备池管理（本地 SQLite 清单，任务调度的数据源） -->
   <div class="sub-panel" id="tools-sub-devpool">
+    <!-- 自动发现：扫描网段 → 待连接池，确认后才加入正式池 -->
+    <div style="border-bottom:1px solid var(--border);margin-bottom:10px;padding-bottom:10px">
+      <div class="toolbar" style="flex-wrap:wrap">
+        <label style="display:inline-flex;align-items:center;gap:4px">
+          <input type="checkbox" id="discovery-enabled" onchange="toggleDiscovery(this.checked)"> 定时扫描
+        </label>
+        <span class="text-muted" style="margin-left:8px">周期</span>
+        <input type="number" id="discovery-interval" style="width:70px" min="10">
+        <span class="text-muted">秒 · 网段</span>
+        <input type="text" id="discovery-subnets" class="form-control" style="width:300px;font-family:monospace"
+               placeholder="192.168.20.0/24, 100.100.10.0/24" title="逗号分隔的 CIDR 网段">
+        <button class="btn" onclick="saveDiscoverySettings()">保存设置</button>
+        <button class="btn btn-primary" onclick="runDiscoveryScan()">立即扫描</button>
+        <span id="discovery-status" class="text-muted"></span>
+      </div>
+      <table class="table table-hover table-sm" style="margin-top:8px">
+        <thead><tr><th>serial</th><th>来源</th><th>首次发现</th><th>最近发现</th><th>在线</th><th>操作</th></tr></thead>
+        <tbody id="tb-discovery"><tr><td colspan="6" class="empty">尚未扫描</td></tr></tbody>
+      </table>
+      <div class="help">扫描局域网/Tailscale 网段中开放 adb 5555 的设备进入<b>待连接池</b>；
+        <b>确认后才加入正式设备池</b>（不自动连接、不参与任务调度）。未授权设备（手机未接受 RSA 弹窗）不会出现。</div>
+      <!-- 正式池断联设备：仍在设备池（不删除、不进待连接池），自动重连中 -->
+      <div style="margin-top:10px">
+        <div style="font-size:12.5px;font-weight:600;margin-bottom:6px">设备池断联设备
+          <span class="text-muted" style="font-weight:400">（仍在设备池内，扫描线程每轮自动重连；也可手动立即重连）</span></div>
+        <table class="table table-hover table-sm">
+          <thead><tr><th>serial</th><th>型号</th><th>备注</th><th>状态</th><th>操作</th></tr></thead>
+          <tbody id="tb-pool-offline"><tr><td colspan="5" class="empty">全部在线</td></tr></tbody>
+        </table>
+      </div>
+    </div>
     <div class="toolbar">
       <input type="text" id="devpool-serial" class="form-control" style="width:220px;font-family:monospace"
              placeholder="serial，如 100.100.10.20:5555" onkeydown="if(event.key==='Enter')addPoolDev()">
@@ -658,6 +815,9 @@ body{background:var(--bg);font-family:var(--body);color:var(--text);font-size:14
       <button class="btn" onclick="reconnectPoolDevices()" title="并发 adb connect 池内全部设备">一键重连</button>
       <button class="btn" onclick="refreshPoolModels()" title="采集池内在线设备的型号（getprop）">采集型号</button>
       <button class="btn" onclick="loadDevPool()">刷新</button>
+      <label style="display:inline-flex;align-items:center;gap:4px;margin:0 6px">
+        <input type="checkbox" id="devpool-filter-online" checked onchange="loadDevPool()"> 只看在线
+      </label>
       <span id="devpool-status" class="text-muted"></span>
     </div>
     <table class="table table-hover table-sm" style="margin-top:8px">
@@ -673,47 +833,32 @@ body{background:var(--bg);font-family:var(--body);color:var(--text);font-size:14
     </div>
   </div>
 
-  <!-- 子分栏 7：远程看屏（MJPEG 实时流 + 触控） -->
-  <div class="sub-panel" id="tools-sub-screen">
+  <!-- 子分栏：设备分组（原顶级 tab，移到工具页） -->
+  <div class="sub-panel" id="tools-sub-groups">
     <div class="toolbar">
-      <select id="screen-device" class="form-control" style="width:300px;font-family:monospace"></select>
-      <button class="btn btn-primary" onclick="startScreenView()">开始看屏</button>
-      <button class="btn" onclick="stopScreenView()">停止</button>
-      <button class="btn" onclick="loadScreenDevices(true)">刷新设备</button>
-      <span id="screen-status" class="text-muted"></span>
-    </div>
-    <div style="display:flex;gap:16px;align-items:flex-start;flex-wrap:wrap">
-      <div style="position:relative" id="screen-stage">
-        <img id="screen-img" alt="远程画面"
-             style="max-width:420px;border-radius:12px;border:1px solid var(--border);background:#000;cursor:crosshair;user-select:none">
-        <div id="screen-loading" class="empty" style="position:absolute;inset:0;display:flex;align-items:center;justify-content:center;background:rgba(0,0,0,.6);color:#fff;border-radius:12px">连接中（首次连接需推送 atx-agent，最长约 30 秒）...</div>
-      </div>
-      <div style="display:flex;flex-direction:column;gap:6px;min-width:200px">
-        <div style="font-size:12px;color:var(--text-light)">操作（鼠标拖拽=滑动，点击=轻触）</div>
-        <div style="display:flex;gap:6px;flex-wrap:wrap">
-          <button class="btn btn-xs" onclick="screenKey('back')">◀ 返回</button>
-          <button class="btn btn-xs" onclick="screenKey('home')">🏠 主页</button>
-          <button class="btn btn-xs" onclick="screenKey('recent')">📋 最近</button>
-          <button class="btn btn-xs" onclick="screenKey('menu')">☰ 菜单</button>
-          <button class="btn btn-xs" onclick="screenKey('power')">⏻ 电源</button>
-          <button class="btn btn-xs" onclick="screenKey('volume_up')">🔊 音量+</button>
-          <button class="btn btn-xs" onclick="screenKey('volume_down')">🔉 音量-</button>
-        </div>
-        <div style="display:flex;gap:6px;margin-top:4px">
-          <input type="text" id="screen-text" class="form-control" style="flex:1" placeholder="输入文字（需光标在输入框）"
-                 onkeydown="if(event.key==='Enter')screenSendText()">
-          <button class="btn btn-xs" onclick="screenSendText()">发送</button>
-        </div>
-        <div class="help" style="margin-top:6px">画面为设备原生分辨率 JPEG 流（约 3-6 帧/秒）。设备息屏时画面为黑，可先点电源/亮屏。</div>
-      </div>
+      <button class="btn btn-primary" onclick="openGroupModal()" data-perm="tasks">新建分组</button>
+      <button class="btn" onclick="loadGroups()">刷新</button>
+      <input class="form-control list-search" id="search-groups" placeholder="搜索分组名/描述...">
+      <span id="groups-status" class="text-muted"></span>
     </div>
+    <table class="table table-hover table-sm" style="margin-top:8px">
+      <thead><tr>
+        <th data-sort="name" onclick="_lpSort('groups','name')">分组名</th><th>描述</th><th data-sort="count" onclick="_lpSort('groups','count')">设备数</th><th>设备列表</th><th>操作</th>
+      </tr></thead>
+      <tbody id="tb-groups"></tbody>
+    </table>
+    <div class="list-pager" id="pager-groups"></div>
+    <div class="help">管理设备分组，用于任务按分组执行。分组内的设备需先在<b>设备池管理</b>中确认（不在池内的设备不参与调度）。</div>
   </div>
+
+
+
 </div>
 
 </div><!-- /.content -->
 
 <!-- ========== 测试此步骤弹窗 ========== -->
-<div id="test-overlay" class="modal-overlay" onclick="if(event.target===this)closeTestModal()">
+<div id="test-overlay" class="modal-overlay" style="z-index:1200" onclick="if(event.target===this)closeTestModal()">
   <div class="modal" id="test-modal-box">
     <div class="modal-header">
       <h3 id="test-modal-title">测试步骤</h3>
@@ -772,5 +917,6 @@ body{background:var(--bg);font-family:var(--body);color:var(--text);font-size:14
 <script src="/static/admin/tools.js"></script>
 <script src="/static/admin/apps.js"></script>
 <script src="/static/admin/admin.js"></script>
+<script src="/static/admin/agent.js"></script>
 </body>
 </html>

templates/admin/wall.html

@@ -0,0 +1,481 @@
+<!DOCTYPE html>
+<html lang="zh-CN">
+<head>
+<meta charset="UTF-8">
+<meta name="viewport" content="width=device-width, initial-scale=1.0">
+<title>设备监控大屏</title>
+<style>
+/* ========== 监控大屏：深色控制室风格 ========== */
+@font-face{font-family:'Bricolage Grotesque';font-style:normal;font-weight:700;font-display:swap;src:url('/static/fonts/bricolage-700.woff2') format('woff2')}
+@font-face{font-family:'Bricolage Grotesque';font-style:normal;font-weight:800;font-display:swap;src:url('/static/fonts/bricolage-800.woff2') format('woff2')}
+@font-face{font-family:'IBM Plex Mono';font-style:normal;font-weight:400;font-display:swap;src:url('/static/fonts/plexmono-400.woff2') format('woff2')}
+@font-face{font-family:'IBM Plex Mono';font-style:normal;font-weight:600;font-display:swap;src:url('/static/fonts/plexmono-600.woff2') format('woff2')}
+:root{
+  --bg:#0d0f13; --card:#14181f; --card-line:#232936; --ink-line:#2a303c;
+  --text:#e8ecf2; --muted:#8b93a3; --faint:#5c6472;
+  --teal:#2dd4bf; --green:#34d399; --red:#f87171; --amber:#fbbf24; --indigo:#818cf8;
+  --display:'Bricolage Grotesque','PingFang SC','Microsoft YaHei',sans-serif;
+  --mono:'IBM Plex Mono',Menlo,Consolas,monospace;
+  --body:-apple-system,'PingFang SC','Microsoft YaHei',sans-serif;
+}
+*{box-sizing:border-box;margin:0;padding:0}
+html,body{height:100%}
+body{background:var(--bg);font-family:var(--body);color:var(--text);overflow:hidden}
+body::before{content:"";position:fixed;inset:0;pointer-events:none;
+  background-image:linear-gradient(rgba(45,212,191,.035) 1px,transparent 1px),
+                   linear-gradient(90deg,rgba(45,212,191,.035) 1px,transparent 1px);
+  background-size:42px 42px}
+/* 顶部栏 */
+header{display:flex;align-items:center;gap:24px;padding:14px 26px 12px;border-bottom:1px solid var(--ink-line);background:rgba(13,15,19,.85);backdrop-filter:blur(6px);position:relative;z-index:5}
+header .title{font-family:var(--display);font-size:21px;font-weight:800;letter-spacing:1px;color:#fff;display:flex;align-items:center;gap:12px;white-space:nowrap}
+header .title::before{content:"";width:10px;height:10px;border-radius:50%;background:var(--teal);box-shadow:0 0 0 0 rgba(45,212,191,.55);animation:pulse 2.2s infinite}
+@keyframes pulse{0%{box-shadow:0 0 0 0 rgba(45,212,191,.5)}70%{box-shadow:0 0 0 9px rgba(45,212,191,0)}100%{box-shadow:0 0 0 0 rgba(45,212,191,0)}}
+header .stats{display:flex;gap:10px;flex:1}
+header .stat{background:var(--card);border:1px solid var(--card-line);border-radius:10px;padding:6px 16px;text-align:center;min-width:84px}
+header .stat .n{font-family:var(--mono);font-size:20px;font-weight:600;line-height:1.15}
+header .stat .l{font-size:11px;color:var(--faint);margin-top:2px;letter-spacing:.4px}
+header .stat.online .n{color:var(--green)}
+header .stat.running .n{color:var(--teal)}
+header .stat.error .n{color:var(--red)}
+header .wall-btn{background:var(--card);border:1px solid var(--card-line);color:var(--teal);border-radius:10px;padding:8px 18px;font-size:13px;font-weight:600;cursor:pointer;transition:all .15s;font-family:var(--body)}
+header .wall-btn:hover{background:#1a2029;border-color:var(--teal);transform:translateY(-1px)}
+header .wall-btn:disabled{opacity:.5;cursor:not-allowed}
+header .clock{font-family:var(--mono);font-size:18px;color:var(--muted);text-align:right;line-height:1.2;white-space:nowrap}
+header .clock .date{font-size:11px;color:var(--faint)}
+/* 设备网格 */
+main{position:relative;z-index:2;height:calc(100vh - 88px);overflow-y:auto;padding:16px 24px 30px;display:grid;grid-template-columns:repeat(auto-fill,minmax(200px,1fr));gap:14px;align-content:start}
+/* 设备卡片（可点击进操作） */
+.card{background:var(--card);border:1px solid var(--card-line);border-radius:14px;overflow:hidden;position:relative;animation:cardIn .4s ease-out backwards;cursor:pointer;transition:border-color .2s,box-shadow .2s,transform .15s}
+.card:hover{transform:translateY(-3px);box-shadow:0 8px 22px rgba(0,0,0,.4)}
+@keyframes cardIn{from{opacity:0;transform:translateY(10px)}to{opacity:1;transform:none}}
+.card.running{border-color:rgba(45,212,191,.55);box-shadow:0 0 18px rgba(45,212,191,.12),inset 0 0 0 1px rgba(45,212,191,.2)}
+.card.error{border-color:rgba(248,113,113,.5)}
+.card.offline{opacity:.62}
+.card .thumb{aspect-ratio:9/16;background:#0a0c10;position:relative;overflow:hidden}
+.card .thumb img{width:100%;height:100%;object-fit:cover;display:block;transition:opacity .2s}
+.card.offline .thumb img{display:none}
+.card .thumb .ph{position:absolute;inset:0;display:none;flex-direction:column;align-items:center;justify-content:center;gap:8px;color:var(--faint);font-size:12px;background:repeating-linear-gradient(45deg,#0c0e12,#0c0e12 12px,#0f1218 12px,#0f1218 24px)}
+.card .thumb .ph .ico{font-size:26px;opacity:.6}
+/* 状态角标 */
+.card .badge{position:absolute;top:8px;left:8px;display:flex;align-items:center;gap:6px;background:rgba(13,15,19,.8);backdrop-filter:blur(4px);border-radius:99px;padding:3px 10px;font-size:11px;font-weight:600;color:var(--muted);border:1px solid var(--ink-line)}
+.card.running .badge{color:var(--teal);border-color:rgba(45,212,191,.4)}
+.card.error .badge{color:var(--red)}
+.card .badge .dot{width:7px;height:7px;border-radius:50%;background:var(--faint)}
+.card.running .badge .dot{background:var(--teal);box-shadow:0 0 7px rgba(45,212,191,.8);animation:pulse 1.6s infinite}
+.card.error .badge .dot{background:var(--red);box-shadow:0 0 6px rgba(248,113,113,.7)}
+.card.offline .badge .dot{background:var(--faint)}
+/* 熄屏角标（右上） */
+.card .screen-tag{position:absolute;top:8px;right:8px;background:rgba(13,15,19,.8);backdrop-filter:blur(4px);border-radius:99px;padding:3px 10px;font-size:11px;font-weight:600;border:1px solid var(--ink-line)}
+.card .screen-tag.on{color:var(--green)}
+.card .screen-tag.off{color:var(--faint)}
+/* 信息区 */
+.card .info{padding:9px 12px 11px}
+.card .info .name{font-size:13.5px;font-weight:700;color:#f1f4f8;white-space:nowrap;overflow:hidden;text-overflow:ellipsis}
+.card .info .ip{font-family:var(--mono);font-size:12px;color:var(--muted);margin-top:2px;white-space:nowrap;overflow:hidden;text-overflow:ellipsis}
+.card .info .model{font-size:10.5px;color:var(--faint);margin-top:2px}
+.card .info .action{font-size:11.5px;color:var(--muted);margin-top:6px;white-space:nowrap;overflow:hidden;text-overflow:ellipsis;min-height:16px}
+.card .info .action b{color:var(--amber);font-weight:600}
+.card .info .prog{margin-top:7px;height:4px;background:#1d242e;border-radius:99px;overflow:hidden}
+.card .info .prog i{display:block;height:100%;background:linear-gradient(90deg,var(--teal),#5eead4);border-radius:99px;transition:width .5s}
+.card .info .prog-txt{font-size:10px;color:var(--faint);margin-top:3px;font-family:var(--mono)}
+.card .info .hint{font-size:10px;color:var(--faint);margin-top:5px;text-align:center;opacity:0;transition:opacity .2s}
+.card:hover .info .hint{opacity:.8}
+/* 空状态 */
+.empty-wall{grid-column:1/-1;text-align:center;color:var(--faint);padding:80px 0;font-size:14px}
+/* 设备操作弹窗 */
+.ctrl-overlay{display:none;position:fixed;inset:0;background:rgba(5,7,10,.78);backdrop-filter:blur(3px);z-index:100;justify-content:center;align-items:center;padding:26px}
+.ctrl-overlay.show{display:flex}
+.ctrl-box{background:var(--card);border:1px solid var(--card-line);border-radius:16px;width:min(420px,94vw);max-height:94vh;display:flex;flex-direction:column;overflow:hidden;box-shadow:0 24px 70px rgba(0,0,0,.6);animation:modalIn .18s ease-out}
+@keyframes modalIn{from{opacity:0;transform:translateY(12px) scale(.98)}to{opacity:1;transform:none}}
+.ctrl-head{padding:12px 16px;border-bottom:1px solid var(--ink-line);display:flex;align-items:center;gap:12px;background:#11151c}
+.ctrl-head .info{flex:1;min-width:0}
+.ctrl-head .name{font-size:15px;font-weight:700;color:#f1f4f8;white-space:nowrap;overflow:hidden;text-overflow:ellipsis}
+.ctrl-head .sub{font-family:var(--mono);font-size:11.5px;color:var(--faint);margin-top:1px}
+.ctrl-head .close{background:none;border:none;color:var(--faint);font-size:22px;cursor:pointer;padding:0 6px;line-height:1;border-radius:6px}
+.ctrl-head .close:hover{color:#fff;background:#1d242e}
+.ctrl-body{flex:1;overflow-y:auto;padding:12px;background:#0a0c10}
+.ctrl-body .screen{position:relative;border-radius:10px;overflow:hidden;background:#000;cursor:crosshair;user-select:none;touch-action:none}
+.ctrl-body .screen img{width:100%;display:block;max-height:62vh;object-fit:contain;background:#000}
+.ctrl-body .screen .loading{position:absolute;inset:0;display:flex;align-items:center;justify-content:center;background:rgba(0,0,0,.55);color:var(--muted);font-size:12px;border-radius:10px}
+.ctrl-tools{display:flex;gap:6px;flex-wrap:wrap;padding:10px 12px 12px;border-top:1px solid var(--ink-line);background:#11151c}
+.ctrl-tools .btn{background:#1a2029;border:1px solid var(--card-line);color:var(--muted);border-radius:8px;padding:6px 12px;font-size:12px;cursor:pointer;transition:all .12s;font-family:var(--body)}
+.ctrl-tools .btn:hover{color:var(--teal);border-color:var(--teal)}
+.ctrl-tools .btn.wake{color:var(--green);border-color:rgba(52,211,153,.4)}
+.ctrl-tools .btn.wake:hover{border-color:var(--green)}
+.ctrl-tools .btn.sleep{color:var(--faint)}
+.ctrl-tools .text-row{display:flex;gap:6px;flex:1 0 100%;margin-top:2px}
+.ctrl-tools .text-row input{flex:1;background:#0d1117;border:1px solid var(--card-line);border-radius:8px;padding:6px 10px;font-size:12px;color:var(--text);outline:none;font-family:var(--body)}
+.ctrl-tools .text-row input:focus{border-color:var(--teal)}
+/* 滚动条 */
+::-webkit-scrollbar{width:8px}
+::-webkit-scrollbar-thumb{background:#232936;border-radius:4px}
+::-webkit-scrollbar-track{background:transparent}
+</style>
+</head>
+<body>
+<header>
+  <div class="title">设备监控大屏</div>
+  <div class="stats" id="wall-stats"></div>
+  <label class="wall-btn" style="display:inline-flex;align-items:center;gap:4px;cursor:pointer">
+    <input type="checkbox" id="wall-filter-online" checked onchange="refreshStatus()"> 只看在线
+  </label>
+  <button class="wall-btn" id="btn-wake-all" onclick="wakeAll()">💡 一键亮屏</button>
+  <div class="clock"><span id="wall-clock">--:--:--</span><div class="date" id="wall-date"></div></div>
+</header>
+<main id="wall-grid"></main>
+
+<!-- 设备操作弹窗（看屏 + 触控） -->
+<div class="ctrl-overlay" id="ctrl-overlay">
+  <div class="ctrl-box">
+    <div class="ctrl-head">
+      <div class="info">
+        <div class="name" id="ctrl-name">设备</div>
+        <div class="sub" id="ctrl-sub">--</div>
+      </div>
+      <button class="close" onclick="closeCtrl()">×</button>
+    </div>
+    <div class="ctrl-body">
+      <div class="screen" id="ctrl-screen">
+        <img id="ctrl-img" alt="">
+        <div class="loading" id="ctrl-loading">连接中（首次需推送 atx-agent，最长约 30 秒）...</div>
+      </div>
+    </div>
+    <div class="ctrl-tools">
+      <button class="btn wake" onclick="ctrlWake()">💡 亮屏</button>
+      <button class="btn sleep" onclick="ctrlSleep()">🌙 息屏</button>
+      <button class="btn" onclick="ctrlKey('back')">◀ 返回</button>
+      <button class="btn" onclick="ctrlKey('home')">🏠 主页</button>
+      <button class="btn" onclick="ctrlKey('recent')">📋 最近</button>
+      <button class="btn" onclick="ctrlKey('menu')">☰ 菜单</button>
+      <button class="btn" onclick="ctrlKey('power')">⏻ 电源</button>
+      <div class="text-row">
+        <input type="text" id="ctrl-text" placeholder="输入文字（需光标在输入框）" onkeydown="if(event.key==='Enter')ctrlSendText()">
+        <button class="btn" onclick="ctrlSendText()">发送</button>
+      </div>
+    </div>
+  </div>
+</div>
+
+<script>
+// ================== 监控大屏（深色控制室） ==================
+// 状态每 5s 刷新；缩略图每 2.5s 轮询（页面不可见时暂停）
+// 缩略图走 fetch 读取 X-Screen-State 头，卡片显示 亮屏中/熄屏中
+const STATUS_MAP={idle:'空闲',connecting:'连接中',running:'运行中',done:'完成',error:'异常',released:'已释放',failed:'失败'};
+const APP_NAMES={'com.ss.android.ugc.aweme':'抖音','com.ss.android.ugc.aweme.lite':'抖音极速版','com.smile.gifmaker':'快手','com.kuaishou.nebula':'快手极速版','com.tencent.mm':'微信','com.tencent.mobileqq':'QQ','com.miui.home':'桌面','com.android.launcher':'桌面','com.android.settings':'设置','com.android.systemui':'系统'};
+let _devices=[];
+let _ctrlSerial='';          // 操作弹窗当前设备
+let _ctrlTimer=null;         // 弹窗状态刷新定时器
+let _screenState={};         // serial -> on/off（来自缩略图响应头）
+
+function esc(s){return String(s||'').replace(/[&<>"']/g,c=>({'&':'&amp;','<':'&lt;','>':'&gt;','"':'&quot;',"'":'&#39;'}[c]));}
+// CSRF：独立页面需先取 token，POST 必须携带（与主后台 base.js 一致）
+let _csrfToken='';
+async function initCsrf(){
+  try{const r=await fetch('/api/csrf');const d=await r.json();_csrfToken=d.token||'';}catch(e){}
+}
+async function apiGet(url){
+  try{
+    const r=await fetch(url);
+    if(r.status===401){window.location='/login';return null;}
+    return await r.json();
+  }catch(e){return null;}
+}
+async function apiPost(url,body){
+  try{
+    const r=await fetch(url,{method:'POST',headers:{'Content-Type':'application/json','X-CSRF-Token':_csrfToken},body:JSON.stringify(body||{})});
+    if(r.status===401){window.location='/login';return null;}
+    return await r.json();
+  }catch(e){return null;}
+}
+
+// 时钟
+function tickClock(){
+  const now=new Date();
+  document.getElementById('wall-clock').textContent=
+    String(now.getHours()).padStart(2,'0')+':'+String(now.getMinutes()).padStart(2,'0')+':'+String(now.getSeconds()).padStart(2,'0');
+  document.getElementById('wall-date').textContent=
+    now.getFullYear()+'-'+String(now.getMonth()+1).padStart(2,'0')+'-'+String(now.getDate()).padStart(2,'0')+' '+['周日','周一','周二','周三','周四','周五','周六'][now.getDay()];
+}
+
+// 状态刷新（5s）
+async function refreshStatus(){
+  const r=await apiGet('/api/status');
+  if(!r||!r.ok)return;
+  const devs=(r.devices||[]).sort((a,b)=>a.serial.localeCompare(b.serial));
+  const changed=JSON.stringify(devs.map(d=>[d.serial,d.present,d.worker_status,d.task_job,d.current_action,d.progress,d.device_name,d.model]))!==
+                JSON.stringify(_devices.map(d=>[d.serial,d.present,d.worker_status,d.task_job,d.current_action,d.progress,d.device_name,d.model]));
+  _devices=devs;
+  renderStats(devs);
+  if(changed)renderGrid(visibleDevs(devs));
+  // 操作弹窗打开时同步刷新其标题状态
+  if(_ctrlSerial)updateCtrlHead();
+}
+
+// 「只看在线」勾选时过滤离线设备（默认勾选）
+function visibleDevs(devs){
+  const onlyOnline=document.getElementById('wall-filter-online')
+    ? document.getElementById('wall-filter-online').checked : true;
+  return onlyOnline? devs.filter(d=>d.present) : devs;
+}
+
+function renderStats(devs){
+  const online=devs.filter(d=>d.present).length;
+  const running=devs.filter(d=>['running','connecting'].includes(d.worker_status)).length;
+  const error=devs.filter(d=>['error','failed'].includes(d.worker_status)).length;
+  document.getElementById('wall-stats').innerHTML=
+    '<div class="stat"><div class="n">'+devs.length+'</div><div class="l">设备总数</div></div>'+
+    '<div class="stat online"><div class="n">'+online+'</div><div class="l">在线</div></div>'+
+    '<div class="stat running"><div class="n">'+running+'</div><div class="l">运行中</div></div>'+
+    '<div class="stat error"><div class="n">'+error+'</div><div class="l">异常</div></div>';
+}
+
+function cardCls(d){
+  if(['error','failed'].includes(d.worker_status))return 'error';
+  if(['running','connecting'].includes(d.worker_status))return 'running';
+  return d.present?'online':'offline';
+}
+// 状态角标文案：运行中/异常优先，其次熄屏/亮屏状态
+function badgeText(d){
+  if(['running','connecting'].includes(d.worker_status))return STATUS_MAP[d.worker_status]||d.worker_status;
+  if(['error','failed'].includes(d.worker_status))return STATUS_MAP[d.worker_status]||d.worker_status;
+  if(!d.present)return '离线';
+  return _screenState[d.serial]==='off'?'熄屏中':'亮屏中';
+}
+function fmtProgress(p){
+  if(!p||!p.total)return '';
+  const pct=Math.min(100,Math.round((p.done||0)/p.total*100));
+  return '<div class="prog"><i style="width:'+pct+'%"></i></div>'+
+         '<div class="prog-txt">'+(p.done||0)+'/'+p.total+(p.unit?' '+esc(p.unit):'')+' · '+pct+'%</div>';
+}
+function shortIp(serial){return String(serial||'').replace(/:5555$/,'');}
+
+function cardHtml(d, i){
+  const cls=cardCls(d);
+  const serial=esc(d.serial);
+  const name=esc(d.device_name||d.model||'设备');
+  const ip=esc(shortIp(d.serial));
+  const st=badgeText(d);
+  const stTag=_screenState[d.serial]==='off'?'<div class="screen-tag off">🌙</div>':'';
+  const action=d.current_action
+    ?'<div class="action">'+(d.task_job?'<b>'+esc(d.task_job)+'</b> · ':'')+esc(d.current_action)+'</div>'
+    :(d.task_job?'<div class="action"><b>'+esc(d.task_job)+'</b></div>':'<div class="action"></div>');
+  return '<div class="card '+cls+'" data-serial="'+serial+'" style="animation-delay:'+(i*30)+'ms" onclick="openCtrl(\''+serial+'\')">'+
+    '<div class="thumb">'+
+      '<img data-thumb="'+serial+'" alt="">'+
+      '<div class="ph"><span class="ico">📱</span><span>'+serial+'</span></div>'+
+      '<div class="badge"><span class="dot"></span>'+st+'</div>'+stTag+
+    '</div>'+
+    '<div class="info">'+
+      '<div class="name">'+name+'</div>'+
+      '<div class="ip">'+ip+'</div>'+
+      '<div class="model">'+esc(d.model||'')+'</div>'+
+      action+fmtProgress(d.progress)+
+      '<div class="hint">点击进入设备操作</div>'+
+    '</div>'+
+  '</div>';
+}
+
+// 增量渲染：已有卡片只更新信息区（不重建 img，缩略图不闪不重载）；增删设备才动 DOM
+function renderGrid(devs){
+  const grid=document.getElementById('wall-grid');
+  if(!devs.length){
+    grid.innerHTML='<div class="empty-wall">设备池为空，请到「工具 → 设备池管理」添加设备</div>';
+    return;
+  }
+  const existing={};
+  grid.querySelectorAll('.card').forEach(c=>{existing[c.dataset.serial]=c;});
+  // 1. 移除已不存在的卡片
+  Object.keys(existing).forEach(s=>{
+    if(!devs.find(d=>d.serial===s))existing[s].remove();
+  });
+  // 2. 更新/新建
+  devs.forEach((d,i)=>{
+    const serial=d.serial;
+    const card=existing[serial];
+    if(card){
+      // 已有卡片：只更新状态类信息（badge/class/信息区），不动 img
+      card.className='card '+cardCls(d);
+      const badge=card.querySelector('.badge');
+      const bt=badgeText(d);
+      if(badge&&badge.textContent!==bt)badge.innerHTML='<span class="dot"></span>'+bt;
+      // 熄屏角标
+      const tag=card.querySelector('.screen-tag');
+      if(_screenState[serial]==='off'&&!tag)card.querySelector('.thumb').insertAdjacentHTML('beforeend','<div class="screen-tag off">🌙</div>');
+      else if(_screenState[serial]!=='off'&&tag)tag.remove();
+      // 信息区
+      card.querySelector('.name').textContent=d.device_name||d.model||'设备';
+      card.querySelector('.ip').textContent=shortIp(serial);
+      card.querySelector('.model').textContent=d.model||'';
+      const action=d.current_action
+        ?(d.task_job?'<b>'+esc(d.task_job)+'</b> · ':'')+esc(d.current_action)
+        :(d.task_job?'<b>'+esc(d.task_job)+'</b>':'');
+      card.querySelector('.action').innerHTML=action;
+      // 进度
+      const progWrap=card.querySelector('.prog-wrap');
+      if(progWrap)progWrap.innerHTML=fmtProgress(d.progress);
+      else if(d.progress&&d.progress.total)card.querySelector('.info').insertAdjacentHTML('beforeend','<div class="prog-wrap">'+fmtProgress(d.progress)+'</div>');
+      // 离线占位切换
+      const img=card.querySelector('img[data-thumb]');
+      const ph=card.querySelector('.ph');
+      if(d.present){if(img)img.style.display='block';if(ph)ph.style.display='none';}
+      else{if(img)img.style.display='none';if(ph)ph.style.display='flex';}
+    }else{
+      grid.insertAdjacentHTML('beforeend',cardHtml(d,i));
+      const nc=grid.lastElementChild;
+      if(!d.present)nc.querySelector('.ph').style.display='flex';
+    }
+  });
+  refreshThumbs();
+}
+
+// 缩略图轮询（2.5s）：fetch 读取 X-Screen-State 头 → blob 喂 img
+async function refreshThumbs(){
+  // 进入设备操作弹窗后：停止全部缩略图获取，资源全部给当前设备的高清流
+  if(_ctrlSerial)return;
+  if(document.visibilityState!=='visible')return;
+  const now=Date.now();
+  const imgs=[...document.querySelectorAll('img[data-thumb]')];
+  await Promise.all(imgs.map(async img=>{
+    const serial=img.dataset.thumb;
+    try{
+      const r=await fetch('/api/screen/thumb?serial='+encodeURIComponent(serial)+'&t='+now);
+      if(!r.ok)return;
+      _screenState[serial]=r.headers.get('X-Screen-State')||'unknown';
+      const blob=await r.blob();
+      if(blob.size>0)img.src=URL.createObjectURL(blob);
+      // 状态角标变化时更新（熄屏中/亮屏中）
+      const card=img.closest('.card');
+      if(card){
+        const d=_devices.find(x=>x.serial===serial);
+        if(d&&d.present&&!(['running','connecting','error','failed'].includes(d.worker_status))){
+          const badge=card.querySelector('.badge');
+          const txt=badgeText(d);
+          if(badge&&badge.textContent!==txt)badge.innerHTML='<span class="dot"></span>'+txt;
+          const tag=card.querySelector('.screen-tag');
+          if(_screenState[serial]==='off'&&!tag)card.querySelector('.thumb').insertAdjacentHTML('beforeend','<div class="screen-tag off">🌙</div>');
+          else if(_screenState[serial]!=='off'&&tag)tag.remove();
+        }
+      }
+    }catch(e){}
+  }));
+}
+
+// ================== 一键亮屏 ==================
+async function wakeAll(){
+  const btn=document.getElementById('btn-wake-all');
+  btn.disabled=true;btn.textContent='亮屏中...';
+  const r=await apiPost('/api/device/screen_all',{mode:'on'});
+  btn.disabled=false;btn.textContent='💡 一键亮屏';
+  if(r&&r.ok){refreshStatus();setTimeout(refreshThumbs,800);}
+}
+
+// ================== 设备操作弹窗（看屏 + 触控） ==================
+function openCtrl(serial){
+  const d=_devices.find(x=>x.serial===serial);
+  if(!d)return;
+  _ctrlSerial=serial;
+  document.getElementById('ctrl-name').textContent=d.device_name||d.model||shortIp(serial);
+  document.getElementById('ctrl-sub').textContent=serial;
+  document.getElementById('ctrl-overlay').classList.add('show');
+  const img=document.getElementById('ctrl-img');
+  img.src='';
+  document.getElementById('ctrl-loading').style.display='flex';
+  img.onload=()=>{document.getElementById('ctrl-loading').style.display='none';};
+  img.onerror=()=>{document.getElementById('ctrl-loading').style.display='none';};
+  startCtrlStream();
+}
+function closeCtrl(){
+  _ctrlSerial='';
+  document.getElementById('ctrl-overlay').classList.remove('show');
+  document.getElementById('ctrl-img').src='';
+}
+function startCtrlStream(){
+  if(!_ctrlSerial)return;
+  const img=document.getElementById('ctrl-img');
+  img.src='/api/screen/stream?serial='+encodeURIComponent(_ctrlSerial)+'&q=85&fps=10&t='+Date.now();  // 弹窗高清高帧
+}
+function updateCtrlHead(){
+  const d=_devices.find(x=>x.serial===_ctrlSerial);
+  if(!d)return;
+  document.getElementById('ctrl-name').textContent=d.device_name||d.model||shortIp(_ctrlSerial);
+  document.getElementById('ctrl-sub').textContent=_ctrlSerial+(d.present?'':'（离线）');
+}
+// 坐标映射：显示尺寸 -> 设备原生分辨率
+// 图片 object-fit:contain 时实际绘制区域小于盒子（居中留黑边），
+// 必须按绘制区域换算，否则黑边/偏移导致点击错位
+function ctrlCoords(ev){
+  const img=document.getElementById('ctrl-img');
+  if(!img.naturalWidth||!img.naturalHeight)return[null,null];
+  const r=img.getBoundingClientRect();
+  const scale=Math.min(r.width/img.naturalWidth,r.height/img.naturalHeight);
+  const drawW=img.naturalWidth*scale, drawH=img.naturalHeight*scale;
+  const ox=(r.width-drawW)/2, oy=(r.height-drawH)/2;   // contain 偏移
+  const px=ev.clientX-r.left, py=ev.clientY-r.top;
+  if(px<ox||px>ox+drawW||py<oy||py>oy+drawH)return[null,null]; // 黑边点击忽略
+  return[Math.round((px-ox)/scale),Math.round((py-oy)/scale)];
+}
+function ctrlTap(x,y){
+  if(x==null||!x)return;
+  apiPost('/api/screen/tap',{serial:_ctrlSerial,x,y});
+}
+function ctrlSwipe(x1,y1,x2,y2){
+  if(x1==null)return;
+  apiPost('/api/screen/swipe',{serial:_ctrlSerial,x1,y1,x2,y2});
+}
+function ctrlKey(key){
+  if(!_ctrlSerial)return;
+  apiPost('/api/screen/key',{serial:_ctrlSerial,key});
+}
+function ctrlWake(){if(_ctrlSerial)apiPost('/api/device/screen_all',{mode:'on',serials:[_ctrlSerial]});}
+function ctrlSleep(){if(_ctrlSerial)apiPost('/api/device/screen_all',{mode:'off',serials:[_ctrlSerial]});}
+function ctrlSendText(){
+  const inp=document.getElementById('ctrl-text');
+  const text=(inp.value||'').trim();
+  if(!_ctrlSerial||!text)return;
+  apiPost('/api/screen/text',{serial:_ctrlSerial,text}).then(r=>{if(r&&r.ok)inp.value='';});
+}
+// 鼠标/触控：拖拽=滑动，点按=轻触
+(function(){
+  const screen=document.getElementById('ctrl-screen');
+  let dragging=false,sx=0,sy=0;
+  screen.addEventListener('mousedown',ev=>{
+    if(!_ctrlSerial)return;
+    ev.preventDefault();dragging=true;
+    const[x,y]=ctrlCoords(ev);sx=x;sy=y;
+  });
+  screen.addEventListener('mousemove',ev=>{if(dragging)ev.preventDefault();});
+  window.addEventListener('mouseup',ev=>{
+    if(!dragging)return;dragging=false;
+    const[x,y]=ctrlCoords(ev);
+    if(x==null)return;
+    if(Math.abs(x-sx)<8&&Math.abs(y-sy)<8)ctrlTap(x,y);
+    else ctrlSwipe(sx,sy,x,y);
+  });
+  screen.addEventListener('touchstart',ev=>{
+    if(!_ctrlSerial)return;
+    ev.preventDefault();const t=ev.touches[0];dragging=true;
+    const[x,y]=ctrlCoords(t);sx=x;sy=y;
+  },{passive:false});
+  screen.addEventListener('touchend',ev=>{
+    if(!dragging)return;dragging=false;
+    const t=ev.changedTouches[0];
+    const[x,y]=ctrlCoords(t);
+    if(x==null)return;
+    if(Math.abs(x-sx)<8&&Math.abs(y-sy)<8)ctrlTap(x,y);
+    else ctrlSwipe(sx,sy,x,y);
+  },{passive:false});
+})();
+
+// 定时器
+setInterval(()=>{if(document.visibilityState==='visible')refreshThumbs();},5000);  // 网格低帧率（省资源）
+setInterval(()=>{if(document.visibilityState==='visible')refreshStatus();},5000);
+
+// 初始化
+initCsrf();tickClock();setInterval(tickClock,1000);
+refreshStatus();
+document.addEventListener('visibilitychange',()=>{
+  if(document.visibilityState==='visible'){refreshStatus();refreshThumbs();}
+});
+</script>
+</body>
+</html>

web/__init__.py

@@ -0,0 +1,31 @@
+"""Web 层蓝图包：web_server.py 只保留 app 初始化与装配，路由按功能域拆分。
+
+模块划分（按功能定位问题）：
+  auth        — 登录/登出/CSRF/权限装饰器/页面路由（/、/wall）
+  monitor     — 状态/运行控制/设备操作/远程看屏
+  tasks       — 任务计划/分组/自定义动作/元素抓取/步骤测试
+  admin       — 用户管理/日志
+  tools       — adb 终端/剪贴板注入/应用版本
+  devices     — 设备池管理
+  apks        — 应用管理
+  tailscale   — Tailscale 管理
+"""
+from flask import Blueprint
+
+
+def register_blueprints(app):
+    """注册全部蓝图（url_prefix 为空，路由路径保持原样）。"""
+    from .auth import bp as auth_bp
+    from .monitor import bp as monitor_bp
+    from .tasks_api import bp as tasks_bp
+    from .admin_api import bp as admin_bp
+    from .tools_api import bp as tools_bp
+    from .devices_api import bp as devices_bp
+    from .apks_api import bp as apks_bp
+    from .tailscale_api import bp as tailscale_bp
+    from . import agent_api as _agent_mod
+    from .agent_api import bp as agent_bp
+    _agent_mod.set_app(app)
+    for bp in (auth_bp, monitor_bp, tasks_bp, admin_bp, tools_bp,
+               devices_bp, apks_bp, tailscale_bp, agent_bp):
+        app.register_blueprint(bp)

web/admin_api.py

@@ -0,0 +1,101 @@
+"""管理域 API：用户管理/日志查看。"""
+import os
+import time
+
+from flask import Blueprint, jsonify, request
+from flask_login import current_user
+from flask import session
+
+from core.logger import _LOG_DIR, _MODULE_FILES
+from core.models import db, User
+from web import context
+from web.auth import (admin_required, perm_required, _validate_perms,
+                             PERM_LOGS)
+
+bp = Blueprint("admin", __name__)
+
+@bp.route("/api/users")
+@admin_required
+def api_users_list():
+    users = [{"id": u.id, "username": u.username,
+              "is_admin": u.is_admin, "perms": u.get_perms()} for u in User.query.all()]
+    return jsonify({"ok": True, "users": users})
+
+@bp.route("/api/users", methods=["POST"])
+@admin_required
+def api_users_create():
+    data = request.json or {}
+    username = (data.get("username") or "").strip()
+    password = data.get("password", "")
+    if not username or not password:
+        return jsonify({"ok": False, "error": "用户名和密码不能为空"}), 400
+    if User.query.filter_by(username=username).first():
+        return jsonify({"ok": False, "error": "用户名已存在"}), 400
+    # 默认普通用户（最小权限）；管理员由 is_admin 决定，权限位照常保存（降级后生效）
+    u = User(username=username, is_admin=bool(data.get("is_admin", False)))
+    u.set_perms(_validate_perms(data.get("perms") or []))
+    u.set_password(password)
+    db.session.add(u)
+    db.session.commit()
+    _log.info(f"创建用户 {username} (admin={u.is_admin}, perms={u.get_perms()})")
+    return jsonify({"ok": True, "msg": "用户已创建"})
+
+@bp.route("/api/users/<int:uid>", methods=["PUT"])
+@admin_required
+def api_users_update(uid):
+    u = User.query.get(uid)
+    if not u:
+        return jsonify({"ok": False, "error": "用户不存在"}), 404
+    data = request.json or {}
+    if "password" in data and data["password"]:
+        u.set_password(data["password"])
+    if "is_admin" in data:
+        new_admin = bool(data["is_admin"])
+        if u.is_admin and not new_admin and User.query.filter_by(is_admin=True).count() <= 1:
+            return jsonify({"ok": False, "error": "不能取消最后一个管理员"}), 400
+        u.is_admin = new_admin
+    if "perms" in data:
+        u.set_perms(_validate_perms(data["perms"]))
+    db.session.commit()
+    _log.info(f"更新用户 {u.username} (admin={u.is_admin}, perms={u.get_perms()})")
+    return jsonify({"ok": True, "msg": "用户已更新"})
+
+@bp.route("/api/users/<int:uid>", methods=["DELETE"])
+@admin_required
+def api_users_delete(uid):
+    u = User.query.get(uid)
+    if not u:
+        return jsonify({"ok": False, "error": "用户不存在"}), 404
+    if u.username == "admin":
+        return jsonify({"ok": False, "error": "不能删除默认管理员"}), 400
+    if u.id == current_user.id:
+        return jsonify({"ok": False, "error": "不能删除当前登录用户"}), 400
+    if u.is_admin and User.query.filter_by(is_admin=True).count() <= 1:
+        return jsonify({"ok": False, "error": "不能删除最后一个管理员"}), 400
+    db.session.delete(u)
+    db.session.commit()
+    _log.info(f"删除用户 {u.username}")
+    return jsonify({"ok": True, "msg": "用户已删除"})
+
+
+# ================== API：日志查看 ==================
+
+@bp.route("/api/logs")
+@perm_required(PERM_LOGS)
+def api_logs():
+    files = list(_MODULE_FILES.values())
+    current = request.args.get("file", "core.log")
+    lines = int(request.args.get("lines", 300))
+    content = ""
+    path = os.path.join(_LOG_DIR, current)
+    if os.path.exists(path):
+        try:
+            with open(path, encoding="utf-8") as f:
+                content = "".join(f.readlines()[-lines:])
+        except Exception as e:
+            content = f"读取失败: {e}"
+    return jsonify({"ok": True, "content": content, "file": current, "files": files})
+
+
+# ================== API：运行控制 ==================
+

web/agent_api.py

@@ -0,0 +1,943 @@
+"""AI 控制台 API：模型/Key 前端配置 + Agent 流式执行（SSE 事件流）。
+
+流程：
+  POST /api/agent/run {prompt}        → 启动 Agent 线程，返回 run_id
+  GET  /api/agent/stream?run_id=      → SSE 事件流（EventSource 订阅）：
+        event: delta  {text, kind: content|reasoning}   流式文本增量
+        event: step   {tool, args, image?}               工具调用完成（MCP 步骤）
+        event: done   {answer}                           完成
+        event: error  {message}                          失败
+  GET/POST /api/agent/config          → 配置读写（key 打码回显）
+
+单实例：同时只允许一个 Agent 运行。
+"""
+import asyncio
+import base64
+import io
+import json
+import os
+import queue
+import re
+import sys
+import threading
+import uuid
+
+from flask import Blueprint, Response, jsonify, request
+
+from core.logger import get_logger
+from core.models import db
+from web.auth import admin_required
+
+_log = get_logger("web.agent")
+bp = Blueprint("agent", __name__)
+
+# ---------- 配置键（app_meta） ----------
+_CFG_KEYS = {"api_base": "agent_api_base",
+             "model": "agent_model",
+             "api_key": "agent_api_key",
+             "default_serial": "agent_default_serial",
+             "max_steps": "agent_max_steps"}
+
+# ---------- 运行状态（单实例 + 事件队列） ----------
+_run = {"id": None, "state": "idle", "prompt": "", "serial": "",
+        "answer": "", "error": "",
+        "history": []}   # 多轮对话历史 [{role: user|assistant, content}]
+_queues = {}            # run_id -> queue.Queue（SSE 消费者读取）
+_stop_events = {}       # run_id -> threading.Event（用户中断）
+_lock = threading.Lock()
+_flask_app = None       # web_server 注册时注入（后台线程 db 操作需 app context）
+
+
+def set_app(app):
+    global _flask_app
+    _flask_app = app
+
+
+def _meta_get(key):
+    return db.session.execute(
+        db.text("SELECT value FROM app_meta WHERE key=:k"), {"k": key}).scalar() or ""
+
+
+def _meta_put(key, value):
+    db.session.execute(
+        db.text("INSERT OR REPLACE INTO app_meta(key,value) VALUES(:k,:v)"),
+        {"k": key, "v": str(value)})
+
+
+def _read_cfg():
+    return {k: _meta_get(v) for k, v in _CFG_KEYS.items()}
+
+
+# ================== 经验记忆（自进化） ==================
+# agent_experience：任务成功后的操作配方，下次相似任务检索注入 system prompt。
+# 原始 SQLite（CREATE IF NOT EXISTS 幂等），不进模型层迁移。
+_EXP_TABLE = """
+CREATE TABLE IF NOT EXISTS agent_experience (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  task_prompt TEXT DEFAULT '',
+  recipe TEXT DEFAULT '',
+  tool_seq TEXT DEFAULT '',
+  hits INTEGER DEFAULT 0,
+  created_at VARCHAR(20) DEFAULT '')"""
+
+# 经验巡检（AI 质检）：每日定时把经验交给模型评审，疑似问题标 pending 待人工确认。
+# 删除只允许人工（前端 confirm / 本 API），巡检绝不自动删。
+_AUDIT_TABLE = """
+CREATE TABLE IF NOT EXISTS experience_audit (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  exp_id INTEGER NOT NULL,
+  verdict TEXT DEFAULT '',       -- keep 保留 / delete 建议删除
+  score REAL DEFAULT 0,          -- 0-10 可用性评分
+  reason TEXT DEFAULT '',        -- 模型给出的理由
+  hits INTEGER DEFAULT 0,        -- 巡检时的引用次数（hits>0 被删要更谨慎）
+  action TEXT DEFAULT 'pending', -- pending 待人工确认 / kept 已保留 / deleted 已删除
+  audited_at VARCHAR(20) DEFAULT '')"""
+
+# 巡检评审提示词：模型只判「保留/建议删除」+ 评分 + 理由，不直接删。
+_AUDIT_PROMPT = """你是「手机自动化经验库」质检员。经验库存放 AI 成功操作手机后提炼的
+操作套路，下次相似任务会自动注入参考。请判断下面这条经验是否值得继续保留。
+
+判断标准（全部满足才保留）：
+1. 具体可执行：步骤是明确的工具操作（de_* 或清晰的中文步骤），不是「de_tap / de_input」
+   这类空泛占位，也没有编造不存在的工具名
+2. 不依赖易过时信息：不含写死的像素坐标（x,y 数字）这类界面一变就失效的步骤
+3. 是独立任务的操作套路（如「打开X搜索Y并点赞」），不是对话追问/抱怨/单次性内容
+4. 配方与下方实际操作序列大致一致，不是模型自由发挥编造
+
+经验内容：
+任务描述：{prompt}
+操作配方：{recipe}
+实际操作序列：{tool_seq}
+被引用次数：{hits}
+
+只输出 JSON：{{"keep": true或false, "score": 0到10的整数, "reason": "一句话中文理由"}}"""
+
+
+def _ensure_exp_table():
+    try:
+        db.session.execute(db.text(_EXP_TABLE))
+        db.session.commit()
+    except Exception:
+        pass
+
+
+def _bigrams(text):
+    """中文/英文文本 bigram 集合（无空格分词，粗粒度相似度）。"""
+    t = "".join(c for c in (text or "").lower() if c.isalnum() or "\u4e00" <= c <= "\u9fff")
+    return {t[i:i + 2] for i in range(len(t) - 1)}
+
+
+# ---------- 经验质量门槛 ----------
+# 自进化经验只应保存「独立操作任务」的成功套路。多轮对话里用户的短句
+# （质疑/纠正/催促，如「继续啊」「你确定我是卡1吗」「还没有完成啊」）
+# 不是新任务——把执行出错被纠正的轮次存成经验会教坏后续任务。
+# 用启发式过滤（零成本，可解释），配方层再校验工具名真实性。
+
+# 任务性动词：命中任一视为有明确操作诉求（疑问/纠错短句一般不含它们）
+_TASK_VERBS = ("打开", "搜索", "查看", "找到", "截图", "输入", "点击", "点开",
+               "发送", "安装", "卸载", "下载", "启动", "停止", "关闭", "退出",
+               "登录", "切换", "设置", "删除", "清理", "复制", "粘贴", "读取",
+               "剪贴板", "长按", "滑动", "播放", "发布", "检查", "看看",
+               "帮我", "给我", "请", "拍张", "查一下")
+# 对话续语开头：几乎只出现在承接上一轮（「继续啊」「还有吗」）
+_CONTINUE_PREFIXES = ("继续", "还有", "然后呢", "再来", "快点", "刚才",
+                      "接着", "上一步")
+# 强质疑/纠错信号（不含「为什么」——「查一下为什么」是正当任务）
+_DOUBT_MARKS = ("你确定", "是不是", "不是吧", "不是吗", "怎么都", "怎么还",
+                "还没有", "没看到", "我说的是", "你听我说", "不对吧", "你又",
+                "重新来", "错了", "你说得", "你回答")
+# 全部真实 MCP 工具（配方里出现不存在的 de_* 说明蒸馏模型在编造，弃存）
+_KNOWN_TOOLS = frozenset({
+    "de_list_devices", "de_screenshot", "de_tap", "de_swipe", "de_ui_tree",
+    "de_tap_element", "de_read_clipboard", "de_wake", "de_press_key",
+    "de_open_app", "de_stop_app", "de_foreground_app", "de_type_text",
+    "de_set_clipboard", "de_sleep", "de_ocr", "de_tap_text", "de_list_apps",
+    "de_list_tasks"})
+
+
+def _qualify_experience(prompt, recipe):
+    """经验入库前质量门槛，返回 True=值得保存。
+
+    1) prompt 太短 / 纯续语开头 / 质疑纠错 → 非独立任务，弃
+    2) 疑问短句（≤30 字、以 吗/？ 结尾）且无任务动词 → 追问/反问，弃
+    3) 配方含不存在的 de_* 工具（蒸馏模型自由发挥）→ 弃
+    """
+    t = "".join(c for c in (prompt or "") if not c.isspace())
+    if len(t) < 6:
+        _log.info("经验弃存：prompt 过短「%s」", t[:20])
+        return False
+    if any(t.startswith(p) for p in _CONTINUE_PREFIXES):
+        _log.info("经验弃存：对话续语开头「%s」", t[:20])
+        return False
+    if any(m in t for m in _DOUBT_MARKS):
+        _log.info("经验弃存：质疑/纠错语气「%s」", t[:20])
+        return False
+    if (t.endswith("吗") or t.endswith("？") or t.endswith("?")) \
+            and len(t) <= 30 and not any(v in t for v in _TASK_VERBS):
+        _log.info("经验弃存：无操作诉求的追问「%s」", t[:20])
+        return False
+    for name in re.findall(r"de_[a-z_]+", recipe or ""):
+        if name not in _KNOWN_TOOLS:
+            _log.info("经验弃存：配方含不存在的工具 %s", name)
+            return False
+    return True
+
+
+def _find_experiences(prompt, limit=2, threshold=0.10):
+    """按 bigram 重叠检索相似历史经验（prompt 与任务描述的字符相似度）。
+
+    命中的经验 hits+1（回写），让被反复参考的有效经验浮到前面。
+    """
+    try:
+        if _flask_app is None:
+            return ""
+        with _flask_app.app_context():
+            _ensure_exp_table()
+            rows = db.session.execute(db.text(
+                "SELECT id, task_prompt, recipe, hits FROM agent_experience "
+                "WHERE recipe != '' ORDER BY hits DESC, id DESC LIMIT 50")).fetchall()
+    except Exception:
+        return ""
+    if not rows:
+        return ""
+    cur = _bigrams(prompt)
+    if not cur:
+        return ""
+    scored = []
+    for row_id, task_prompt, recipe, hits in rows:
+        sim = len(cur & _bigrams(task_prompt)) / len(cur)
+        if sim >= threshold:
+            scored.append((sim, hits or 0, recipe, row_id))
+    scored.sort(key=lambda x: (-x[0], -x[1]))
+    if scored:
+        # hits 回写（尽力而为，失败不影响检索）
+        try:
+            with _flask_app.app_context():
+                for _sim, _hits, _recipe, row_id in scored:
+                    db.session.execute(db.text(
+                        "UPDATE agent_experience SET hits=hits+1 WHERE id=:i"),
+                        {"i": row_id})
+                db.session.commit()
+        except Exception:
+            pass
+    parts = []
+    for sim, _hits, recipe, _row_id in scored[:limit]:
+        parts.append(f"- {recipe[:600]}")
+    return "\n".join(parts)
+
+
+def _distill_experience(cfg, prompt, tool_seq):
+    """任务完成后用模型把操作序列提炼为可复用配方（失败静默，不阻塞）。"""
+    try:
+        import httpx
+        body = {
+            "model": cfg.get("model") or "deepseek-v4-flash-vision-exp",
+            "messages": [{"role": "user",
+                          "content": "以下是一次成功的手机自动化操作记录。请提炼成简洁的"
+                                     "「操作配方」（2-6 步，每步：目标 → 用哪个工具），"
+                                     "供下次同类任务参考。不要解释，直接输出配方。\n"
+                                     f"任务：{prompt[:300]}\n操作序列：{tool_seq[:800]}"}],
+            "max_tokens": 600,
+        }
+        headers = {"Authorization": f"Bearer {cfg.get('api_key', '')}",
+                   "Content-Type": "application/json"}
+        r = httpx.post(f"{(cfg.get('api_base') or 'https://api.deepseek.com').rstrip('/')}/chat/completions",
+                       json=body, headers=headers, timeout=25)
+        if r.status_code != 200:
+            return ""
+        j = r.json()
+        recipe = ((j.get("choices") or [{}])[0].get("message") or {}).get("content") or ""
+        return recipe.strip()[:1500]
+    except Exception as e:
+        _log.warning(f"经验提炼失败: {e}")
+        return ""
+
+
+def _save_experience(prompt, recipe, tool_seq):
+    """保存经验（后台线程调用，包 app context）。返回是否保存成功。"""
+    try:
+        if _flask_app is None:
+            return False
+        with _flask_app.app_context():
+            _ensure_exp_table()
+            from datetime import datetime
+            db.session.execute(db.text(
+                "INSERT INTO agent_experience(task_prompt, recipe, tool_seq, hits, created_at) "
+                "VALUES(:p, :r, :t, 0, :c)"),
+                {"p": prompt[:500], "r": recipe, "t": tool_seq[:1000],
+                 "c": datetime.now().strftime("%Y-%m-%d %H:%M")})
+            db.session.commit()
+            _log.info("经验已保存（配方 %d 字符）", len(recipe))
+            return True
+    except Exception as e:
+        _log.warning(f"经验保存失败: {e}")
+        return False
+
+
+# ================== 经验巡检（AI 质检，删除需人工确认） ==================
+_audit_state = {"running": False, "last": "", "last_summary": ""}
+
+
+def _ensure_audit_table():
+    try:
+        db.session.execute(db.text(_AUDIT_TABLE))
+        db.session.commit()
+    except Exception:
+        pass
+
+
+def _review_one_exp(cfg, prompt, recipe, tool_seq, hits):
+    """调模型评审单条经验，返回 (verdict, score, reason)。
+
+    模型偶尔输出解释文字不带 JSON——重试一次（强调只输出 JSON），
+    仍失败则保守返回保留。
+    """
+    import httpx
+    base_prompt = _AUDIT_PROMPT.format(prompt=(prompt or "")[:400],
+                                       recipe=(recipe or "")[:600],
+                                       tool_seq=(tool_seq or "")[:600],
+                                       hits=hits or 0)
+    for attempt in (1, 2):
+        try:
+            content = base_prompt if attempt == 1 else (
+                base_prompt + "\n注意：只输出一个 JSON 对象，不要输出任何其它文字、解释或代码块标记。")
+            body = {
+                "model": cfg.get("model") or "deepseek-v4-flash-vision-exp",
+                "messages": [{"role": "user", "content": content}],
+                "max_tokens": 200,
+            }
+            headers = {"Authorization": f"Bearer {cfg.get('api_key', '')}",
+                       "Content-Type": "application/json"}
+            r = httpx.post(f"{(cfg.get('api_base') or 'https://api.deepseek.com').rstrip('/')}/chat/completions",
+                           json=body, headers=headers, timeout=20)
+            if r.status_code != 200:
+                raise RuntimeError(f"HTTP {r.status_code}")
+            text = (((r.json() or {}).get("choices") or [{}])[0]
+                    .get("message") or {}).get("content") or ""
+            m = re.search(r"\{.*\}", text, re.S)
+            if not m:
+                raise RuntimeError("响应无 JSON")
+            j = json.loads(m.group(0))
+            keep = bool(j.get("keep", True))
+            score = max(0, min(10, int(j.get("score", 5) or 5)))
+            reason = str(j.get("reason", ""))[:200]
+            return ("keep" if keep else "delete"), score, reason
+        except Exception as e:
+            _log.warning(f"经验评审第 {attempt} 次失败: {e}")
+    return "keep", 0, "评审失败自动保留（两次尝试均无有效 JSON）"
+
+
+def run_experience_audit():
+    """巡检一轮：逐条评审经验 → 写 experience_audit。
+
+    规则：
+      - 最新已 kept / deleted 的经验不再重复评审（人工拍板过的尊重）
+      - 评审 keep → 直接 action=kept；delete → action=pending（等人工确认）
+      - 绝不自动删除；无 api_key 配置时跳过并记日志
+    由 web_server 每日定时调度或 API 手动触发（后台线程）。
+    """
+    if _audit_state["running"]:
+        _log.info("经验巡检已在运行，跳过本次触发")
+        return
+    _audit_state["running"] = True
+    try:
+        if _flask_app is None:
+            return
+        with _flask_app.app_context():
+            _ensure_exp_table()
+            _ensure_audit_table()
+            cfg = _read_cfg()
+            if not cfg.get("api_key"):
+                _log.info("经验巡检跳过：未配置 API Key")
+                return
+            rows = db.session.execute(db.text(
+                "SELECT id, task_prompt, recipe, tool_seq, hits FROM agent_experience "
+                "ORDER BY id")).fetchall()
+            if not rows:
+                _log.info("经验巡检：经验库为空")
+                return
+            from datetime import datetime
+            now = datetime.now().strftime("%Y-%m-%d %H:%M")
+            reviewed = suggested = 0
+            for exp_id, prompt, recipe, tool_seq, hits in rows:
+                # 最新一次人工/评审结论：kept / deleted 的不再打扰
+                last = db.session.execute(db.text(
+                    "SELECT action FROM experience_audit WHERE exp_id=:e "
+                    "ORDER BY id DESC LIMIT 1"), {"e": exp_id}).scalar()
+                if last in ("kept", "deleted"):
+                    continue
+                verdict, score, reason = _review_one_exp(
+                    cfg, prompt, recipe, tool_seq, hits)
+                action = "kept" if verdict == "keep" else "pending"
+                db.session.execute(db.text(
+                    "INSERT INTO experience_audit"
+                    "(exp_id, verdict, score, reason, hits, action, audited_at) "
+                    "VALUES(:e, :v, :s, :r, :h, :a, :t)"),
+                    {"e": exp_id, "v": verdict, "s": score, "r": reason,
+                     "h": hits or 0, "a": action, "t": now})
+                reviewed += 1
+                suggested += 1 if action == "pending" else 0
+            db.session.commit()
+            summary = f"评审 {reviewed} 条，建议删除 {suggested} 条（待人工确认）"
+            _audit_state.update(last=now, last_summary=summary)
+            _log.info("经验巡检完成: %s", summary)
+    except Exception as e:
+        _log.warning(f"经验巡检异常: {e}")
+    finally:
+        _audit_state["running"] = False
+
+
+# ================== 经验库管理 API ==================
+@bp.route("/api/agent/experience")
+@admin_required
+def agent_experience_list():
+    """经验库列表（含最近一次巡检结论），供 AI 控制台「🧠 经验库」面板管理。"""
+    _ensure_exp_table()
+    _ensure_audit_table()
+    rows = db.session.execute(db.text(
+        "SELECT e.id, e.task_prompt, e.recipe, e.tool_seq, e.hits, e.created_at, "
+        "a.verdict, a.score, a.reason, a.action, a.audited_at "
+        "FROM agent_experience e LEFT JOIN experience_audit a ON a.id = "
+        "(SELECT id FROM experience_audit WHERE exp_id = e.id ORDER BY id DESC LIMIT 1) "
+        "ORDER BY e.id DESC")).fetchall()
+    exps = []
+    for r in rows:
+        (eid, task_prompt, recipe, tool_seq, hits, created_at,
+         verdict, score, reason, action, audited_at) = r
+        audit = None
+        if action:
+            audit = {"verdict": verdict, "score": round(score or 0, 1),
+                     "reason": reason, "action": action, "at": audited_at}
+        exps.append({"id": eid, "task_prompt": task_prompt or "",
+                     "recipe": recipe or "", "tool_seq": tool_seq or "",
+                     "hits": hits or 0, "created_at": created_at or "",
+                     "audit": audit})
+    return jsonify({"ok": True, "running": _audit_state["running"],
+                    "last": _audit_state["last"],
+                    "last_summary": _audit_state["last_summary"],
+                    "experiences": exps})
+
+
+@bp.route("/api/agent/experience/delete", methods=["POST"])
+@admin_required
+def agent_experience_delete():
+    """人工确认删除经验（真删；前端有二次确认，巡检绝不自动调它）。"""
+    data = request.json or {}
+    exp_id = int(data.get("id") or 0)
+    if exp_id <= 0:
+        return jsonify({"ok": False, "error": "缺少 id"}), 400
+    db.session.execute(db.text(
+        "DELETE FROM agent_experience WHERE id=:i"), {"i": exp_id})
+    db.session.execute(db.text(
+        "UPDATE experience_audit SET action='deleted' "
+        "WHERE exp_id=:i AND action='pending'"), {"i": exp_id})
+    db.session.commit()
+    _log.info("人工确认删除经验 #%d", exp_id)
+    return jsonify({"ok": True, "msg": f"经验 #{exp_id} 已删除"})
+
+
+@bp.route("/api/agent/experience/audit", methods=["POST"])
+@admin_required
+def agent_experience_audit_now():
+    """手动触发一轮经验巡检（后台线程；进行中返回 409）。"""
+    if _audit_state["running"]:
+        return jsonify({"ok": False, "error": "巡检正在进行中"}), 409
+    threading.Thread(target=run_experience_audit, daemon=True).start()
+    return jsonify({"ok": True, "msg": "巡检已启动，完成后刷新列表查看建议"})
+
+
+@bp.route("/api/agent/experience/keep", methods=["POST"])
+@admin_required
+def agent_experience_keep():
+    """人工保留：撤销建议删除（该条后续巡检不再重复建议）。"""
+    data = request.json or {}
+    exp_id = int(data.get("id") or 0)
+    if exp_id <= 0:
+        return jsonify({"ok": False, "error": "缺少 id"}), 400
+    db.session.execute(db.text(
+        "UPDATE experience_audit SET action='kept' "
+        "WHERE exp_id=:i AND action='pending'"), {"i": exp_id})
+    db.session.commit()
+    return jsonify({"ok": True, "msg": f"经验 #{exp_id} 已保留"})
+
+# ================== 历史会话（DeepSeek 式：多会话持久化） ==================
+# 会话 = 消息序列（JSON），一轮 run 的 user/assistant 文本完成后追加落库。
+# 单表 JSON 存储（每会话几十 KB 内，无需独立消息表）。
+_CONV_TABLE = """
+CREATE TABLE IF NOT EXISTS agent_conversation (
+  id VARCHAR(20) PRIMARY KEY,
+  title VARCHAR(100) DEFAULT '',
+  messages TEXT DEFAULT '[]',
+  created_at VARCHAR(20) DEFAULT '',
+  updated_at VARCHAR(20) DEFAULT '')"""
+
+
+def _ensure_conv_table():
+    try:
+        db.session.execute(db.text(_CONV_TABLE))
+        db.session.commit()
+    except Exception:
+        pass
+
+
+def _conv_msgs(conv_id):
+    """读会话消息列表 [{role, content}]。会话不存在返回 None。"""
+    try:
+        row = db.session.execute(db.text(
+            "SELECT messages FROM agent_conversation WHERE id=:i"),
+            {"i": conv_id}).fetchone()
+    except Exception:
+        return None
+    if not row:
+        return None
+    try:
+        return json.loads(row[0] or "[]")
+    except Exception:
+        return []
+
+
+def _conv_save_messages(conv_id, messages, title=None):
+    """整段写回会话消息 + 时间戳（尽力而为，失败不影响主流程）。"""
+    try:
+        from datetime import datetime
+        now = datetime.now().strftime("%Y-%m-%d %H:%M")
+        msgs_json = json.dumps(messages[-60:], ensure_ascii=False)
+        if title:
+            db.session.execute(db.text(
+                "UPDATE agent_conversation SET messages=:m, title=:t, "
+                "updated_at=:u WHERE id=:i"),
+                {"m": msgs_json, "t": title[:100], "u": now, "i": conv_id})
+        else:
+            db.session.execute(db.text(
+                "UPDATE agent_conversation SET messages=:m, updated_at=:u "
+                "WHERE id=:i"),
+                {"m": msgs_json, "u": now, "i": conv_id})
+        db.session.commit()
+        return True
+    except Exception as e:
+        _log.warning(f"会话保存失败: {e}")
+        return False
+
+
+@bp.route("/api/agent/conversations", methods=["GET"])
+@admin_required
+def agent_conversations_list():
+    """会话列表（按最近更新倒序）：{id, title, updated_at, count}。"""
+    _ensure_conv_table()
+    rows = db.session.execute(db.text(
+        "SELECT id, title, messages, updated_at FROM agent_conversation "
+        "ORDER BY updated_at DESC, created_at DESC")).fetchall()
+    out = []
+    for cid, title, messages, updated_at in rows:
+        try:
+            count = len(json.loads(messages or "[]")) // 2
+        except Exception:
+            count = 0
+        out.append({"id": cid, "title": title or "新会话",
+                    "updated_at": updated_at or "", "count": count})
+    return jsonify({"ok": True, "conversations": out})
+
+
+@bp.route("/api/agent/conversations", methods=["POST"])
+@admin_required
+def agent_conversations_create():
+    """新建会话（空消息）。返回 {id}。"""
+    _ensure_conv_table()
+    from datetime import datetime
+    cid = uuid.uuid4().hex[:10]
+    now = datetime.now().strftime("%Y-%m-%d %H:%M")
+    db.session.execute(db.text(
+        "INSERT INTO agent_conversation(id, title, messages, created_at, updated_at) "
+        "VALUES(:i, '', '[]', :c, :c)"), {"i": cid, "c": now})
+    db.session.commit()
+    return jsonify({"ok": True, "id": cid, "title": "新会话"})
+
+
+@bp.route("/api/agent/conversations/<conv_id>", methods=["GET"])
+@admin_required
+def agent_conversations_detail(conv_id):
+    """会话详情（全部消息文本）。"""
+    _ensure_conv_table()
+    msgs = _conv_msgs(conv_id)
+    if msgs is None:
+        return jsonify({"ok": False, "error": "会话不存在"}), 404
+    row = db.session.execute(db.text(
+        "SELECT title, created_at, updated_at FROM agent_conversation "
+        "WHERE id=:i"), {"i": conv_id}).fetchone()
+    return jsonify({"ok": True, "id": conv_id,
+                    "title": (row[0] if row else "") or "新会话",
+                    "messages": msgs,
+                    "created_at": row[1] if row else "",
+                    "updated_at": row[2] if row else ""})
+
+
+@bp.route("/api/agent/conversations/<conv_id>", methods=["DELETE"])
+@admin_required
+def agent_conversations_delete(conv_id):
+    """删除会话（消息一并删除，不可恢复）。"""
+    _ensure_conv_table()
+    db.session.execute(db.text(
+        "DELETE FROM agent_conversation WHERE id=:i"), {"i": conv_id})
+    db.session.commit()
+    _log.info(f"删除会话 {conv_id}")
+    return jsonify({"ok": True, "msg": "会话已删除"})
+
+
+@bp.route("/api/agent/conversations/<conv_id>/rename", methods=["POST"])
+@admin_required
+def agent_conversations_rename(conv_id):
+    """重命名会话。"""
+    data = request.json or {}
+    title = (data.get("title") or "").strip()[:100]
+    if not title:
+        return jsonify({"ok": False, "error": "标题不能为空"}), 400
+    _ensure_conv_table()
+    db.session.execute(db.text(
+        "UPDATE agent_conversation SET title=:t WHERE id=:i"),
+        {"t": title, "i": conv_id})
+    db.session.commit()
+    return jsonify({"ok": True, "msg": "已重命名"})
+
+
+# ================== 运行 ==================
+@bp.route("/api/agent/run", methods=["POST"])
+@admin_required
+def agent_run():
+    """启动 Agent：{prompt, serial?, conversation_id?}。运行中返回 409。"""
+    data = request.json or {}
+    prompt = (data.get("prompt") or "").strip()
+    if not prompt:
+        return jsonify({"ok": False, "error": "请输入指令"}), 400
+    serial = (data.get("serial") or "").strip()
+    conv_id = (data.get("conversation_id") or "").strip()
+    cfg = _read_cfg()
+    if not cfg.get("api_key"):
+        return jsonify({"ok": False, "error": "请先在配置区填写 API Key"}), 400
+    if not cfg.get("model"):
+        return jsonify({"ok": False, "error": "请先填写模型名"}), 400
+    if not serial and not (cfg.get("default_serial") or "").strip():
+        return jsonify({"ok": False, "error": "请先选择目标设备（AI 只操作你指定的设备）"}), 400
+    # 目标设备校验：必须在池、在线、且无任务运行（AI 不与任务抢设备；
+    # MCP 层另有 busy 锁兜底外部客户端）
+    if serial:
+        try:
+            from web import context
+            devs, err = context.mgr.get_status()
+            dev = next((x for x in (devs or []) if x.get("serial") == serial), None)
+            if err or dev is None:
+                return jsonify({"ok": False, "error": f"设备 {serial} 不在设备池"}), 400
+            if not dev.get("present"):
+                return jsonify({"ok": False, "error": f"设备 {serial} 当前离线，请稍后再试"}), 400
+            if dev.get("worker_status") in ("running", "connecting"):
+                return jsonify({"ok": False, "error":
+                    f"设备 {serial} 正在执行任务「{dev.get('task_job') or ''}」——"
+                    f"AI 不与任务抢设备，任务结束后才能操作（或在任务页先停止）"}), 409
+        except Exception:
+            pass  # 状态服务异常不阻塞（MCP busy 锁兜底）
+    # 会话校验：不存在则自动新建（标题=首条消息截断）
+    if conv_id:
+        _ensure_conv_table()
+        if _conv_msgs(conv_id) is None:
+            try:
+                from datetime import datetime as _dt2
+                now = _dt2.now().strftime("%Y-%m-%d %H:%M")
+                db.session.execute(db.text(
+                    "INSERT OR IGNORE INTO agent_conversation(id, messages, "
+                    "created_at, updated_at) VALUES(:i, '[]', :c, :c)"),
+                    {"i": conv_id, "c": now})
+                db.session.commit()
+            except Exception:
+                pass
+    with _lock:
+        if _run["state"] == "running":
+            return jsonify({"ok": False, "error":
+                f"已有 Agent 运行中（{_run.get('prompt', '')[:40]}…），"
+                f"请等待完成或先停止"}), 409
+        run_id = uuid.uuid4().hex[:8]
+        from datetime import datetime as _dt
+        _run.update(id=run_id, state="running", prompt=prompt,
+                    serial=serial, conv_id=conv_id,
+                    started=_dt.now().strftime("%H:%M:%S"),
+                    answer="", error="")
+        # history 保留（多轮上下文），由会话/「新建会话」管理
+        _queues[run_id] = queue.Queue()
+        _stop_events[run_id] = threading.Event()
+    _log.info(f"Agent 启动: {prompt[:60]} @ {serial or 'default'} conv={conv_id or '-'}")
+    threading.Thread(target=_agent_thread,
+                     args=(run_id, prompt, serial, cfg),
+                     daemon=True).start()
+    return jsonify({"ok": True, "run_id": run_id})
+@bp.route("/api/agent/config", methods=["GET"])
+@admin_required
+def agent_config_get():
+    """读 Agent 配置（key 打码返回）。"""
+    cfg = _read_cfg()
+    if cfg["api_key"]:
+        k = cfg["api_key"]
+        cfg["api_key_masked"] = k[:6] + "***" + k[-4:]
+    return jsonify({"ok": True, **cfg})
+
+
+@bp.route("/api/agent/config", methods=["POST"])
+@admin_required
+def agent_config_save():
+    """保存 Agent 配置：{api_base?, model?, api_key?, default_serial?} 部分更新。"""
+    data = request.json or {}
+    for key, meta_key in _CFG_KEYS.items():
+        if key in data and data[key] is not None:
+            _meta_put(meta_key, str(data[key]).strip())
+    db.session.commit()
+    return jsonify({"ok": True, "msg": "已保存"})
+
+
+@bp.route("/api/agent/run", methods=["GET"])
+@admin_required
+def agent_run_status():
+    """当前 Agent 运行状态（多窗口/页面刷新恢复用）：
+    idle/running/done + run_id + 最终答案 + 会话历史。
+
+    前端刷新后据此：渲染历史轮次、running 时重新订阅事件流（服务端队列
+    保留积压事件，重连后补发）、done 时展示最终答案。
+    """
+    with _lock:
+        hist = [{"role": h.get("role"), "content": (h.get("content") or "")[:4000]}
+                for h in (_run.get("history") or [])]
+        return jsonify({"ok": True,
+                        "state": _run.get("state", "idle"),
+                        "run_id": _run.get("id") or "",
+                        "prompt": _run.get("prompt", ""),
+                        "serial": _run.get("serial", ""),
+                        "started": _run.get("started", ""),
+                        "answer": (_run.get("answer") or "")[:4000],
+                        "error": (_run.get("error") or "")[:400],
+                        "history": hist[-16:]})
+
+
+@bp.route("/api/agent/devices")
+@admin_required
+def agent_devices():
+    """AI 可用设备列表：在线状态 + 是否有任务运行（前端选择器 busy 设备禁选）。
+
+    worker 状态实时（内存）；busy = 任务 running/connecting。
+    """
+    try:
+        from web import context
+        devs, err = context.mgr.get_status()
+    except Exception as e:
+        return jsonify({"ok": False, "error": str(e)[:120]}), 503
+    out = []
+    for d in (devs or []):
+        busy = d.get("worker_status") in ("running", "connecting")
+        out.append({"serial": d.get("serial"),
+                    "model": d.get("model") or "",
+                    "online": bool(d.get("present")),
+                    "busy": busy,
+                    "worker_status": d.get("worker_status") or "idle",
+                    "task_job": d.get("task_job") or ""})
+    return jsonify({"ok": True, "devices": out})
+
+
+@bp.route("/api/agent/stream")
+@admin_required
+def agent_stream():
+    """SSE 事件流（EventSource）：delta/step/done/error。"""
+    run_id = request.args.get("run_id", "")
+    with _lock:
+        if run_id != _run["id"]:
+            return jsonify({"ok": False, "error": "run_id 不存在"}), 404
+        q = _queues.get(run_id)
+
+    def gen():
+        while True:
+            try:
+                evt = q.get(timeout=15)
+            except queue.Empty:
+                yield ": keepalive\n\n"   # 心跳防超时
+                continue
+            if evt is None:
+                break
+            kind, payload = evt
+            yield f"event: {kind}\ndata: {json.dumps(payload, ensure_ascii=False)}\n\n"
+            if kind in ("done", "error"):
+                break
+
+    return Response(gen(), mimetype="text/event-stream",
+                    headers={"Cache-Control": "no-cache",
+                             "X-Accel-Buffering": "no"})
+
+
+@bp.route("/api/agent/stop", methods=["POST"])
+@admin_required
+def agent_stop():
+    """中断当前运行的 Agent（下一个检查点生效，通常在数秒内）。"""
+    with _lock:
+        if _run["state"] != "running":
+            return jsonify({"ok": False, "error": "当前没有运行中的任务"}), 400
+        evt = _stop_events.get(_run["id"])
+    if evt:
+        evt.set()
+        _log.info("用户请求中断 Agent")
+    return jsonify({"ok": True, "msg": "已请求停止"})
+
+
+@bp.route("/api/agent/clear", methods=["POST"])
+@admin_required
+def agent_clear():
+    """清空对话历史。"""
+    with _lock:
+        _run["history"] = []
+    return jsonify({"ok": True, "msg": "已清空"})
+
+
+def _shrink_image(b64, width=220, quality=50):
+    """截图降采样（SSE step 事件用，控制传输体积）。失败原样返回。"""
+    try:
+        from PIL import Image
+        img = Image.open(io.BytesIO(base64.b64decode(b64)))
+        if img.width > width:
+            img = img.resize((width, int(img.height * width / img.width)))
+        buf = io.BytesIO()
+        img.convert("RGB").save(buf, "JPEG", quality=quality)
+        return base64.b64encode(buf.getvalue()).decode()
+    except Exception:
+        return b64
+
+
+def _agent_thread(run_id, prompt, serial, cfg):
+    """后台线程：Agent 流式执行，事件推入队列供 SSE 消费。"""
+    q = _queues.get(run_id)
+    try:
+        # 平台进程 cwd=/app（含 mcp_agent 包），进程内 import
+        sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+        from mcp_agent.agent import Agent
+
+        def on_delta(text, kind):
+            q.put(("delta", {"text": text, "kind": kind}))
+
+        tool_seq = []   # 本轮工具序列（经验提炼用）
+
+        def on_tool(step):
+            # args 保留对象（json.dumps 序列化）——前端要解析 serial 做画面跟随；
+            # 之前 str() 成 Python repr（单引号）导致前端 JSON.parse 失败、跟随失效
+            rec = {"tool": step.get("tool"),
+                   "args": step.get("args") or {}}
+            if step.get("image"):
+                rec["image"] = _shrink_image(step["image"])
+            q.put(("step", rec))
+            # 记录精简工具序列
+            try:
+                args = step.get("args") or {}
+                brief = {k: v for k, v in args.items() if k != "serial"}
+                tool_seq.append(f"{step.get('tool')}({str(brief)[:60]})")
+            except Exception:
+                pass
+
+        agent = Agent()
+        agent.s.api_base = cfg.get("api_base") or agent.s.api_base
+        agent.s.model = cfg.get("model") or agent.s.model
+        agent.s.api_key = cfg.get("api_key") or agent.s.api_key
+        agent.s.default_serial = cfg.get("default_serial") or agent.s.default_serial
+        try:
+            agent.s.max_steps = max(1, min(200, int(cfg.get("max_steps") or 40)))
+        except (TypeError, ValueError):
+            pass  # 非法值用默认 40
+
+        with _lock:
+            conv_id = _run.get("conv_id") or ""
+        # 历史来源：绑定了会话 → 从会话读（多轮上下文延续，DeepSeek 式）；
+        # 无会话（CLI/兼容）→ 用运行态 history
+        if conv_id:
+            # 后台线程需自行推 app context（与 _find_experiences 同思路）
+            with _flask_app.app_context():
+                msgs = _conv_msgs(conv_id)
+            history = [{"role": m.get("role"), "content": m.get("content", "")[:4000]}
+                       for m in (msgs or []) if m.get("role") in ("user", "assistant")]
+            history = history[-24:]
+            with _lock:
+                _run["history"] = list(history)
+        else:
+            with _lock:
+                history = list(_run.get("history") or [])
+        target = serial or cfg.get("default_serial") or ""
+        stop_evt = _stop_events.get(run_id)
+
+        # 经验检索：相似历史任务的操作配方注入 system（自进化记忆）
+        exp_ctx = _find_experiences(prompt)
+        if exp_ctx:
+            _log.info("命中历史经验，注入参考配方")
+            q.put(("step", {"tool": "🧠 经验记忆",
+                            "args": f"命中 {exp_ctx.count(chr(10) + '- ')} 条同类历史经验，已注入参考",
+                            "image": None}))
+
+        async def _execute():
+            await agent._load_tools()
+            return await agent.run_stream(prompt, target,
+                                          history=history,
+                                          on_delta=on_delta, on_tool=on_tool,
+                                          should_stop=lambda: bool(
+                                              stop_evt and stop_evt.is_set()),
+                                          extra_context=exp_ctx)
+
+        # 整体超时保护：卡死时结束，释放单实例
+        answer = asyncio.run(asyncio.wait_for(_execute(), timeout=900))
+        with _lock:
+            _run["state"] = "done"
+            _run["answer"] = answer
+            # 追加本轮进历史（多轮连续性；上限 12 轮防 token 膨胀）
+            hist = _run.setdefault("history", [])
+            hist.append({"role": "user", "content": prompt[:2000]})
+            hist.append({"role": "assistant", "content": (answer or "")[:4000]})
+            _run["history"] = hist[-24:]
+        # 会话落库：本轮追加写回（新会话自动用首条消息作标题）。
+        # 后台线程 db 访问需 app context。
+        if conv_id and _flask_app is not None:
+            try:
+                with _flask_app.app_context():
+                    saved = list(_run["history"])
+                    title = None
+                    if not db.session.execute(db.text(
+                            "SELECT title FROM agent_conversation WHERE id=:i"),
+                            {"i": conv_id}).scalar():
+                        title = "".join(prompt.split())[:30] or "新会话"
+                    _conv_save_messages(conv_id, saved, title=title)
+                _log.info(f"会话已保存: {conv_id}（{len(saved)} 条消息）")
+            except Exception as e:
+                _log.warning(f"会话落库失败: {e}")
+
+        # 自进化：成功执行过工具则提炼配方写入经验。必须在 done 之前完成——
+        # done 发出后 SSE 关流，用户就看不到「已写入经验」的提示了。
+        # 提炼/保存失败静默（不阻塞、不影响结果），只在成功时推送 🧠 卡片。
+        if tool_seq:
+            try:
+                recipe = _distill_experience(cfg, prompt, " -> ".join(tool_seq))
+                if recipe and "配方" not in recipe[:50]:
+                    if _qualify_experience(prompt, recipe):
+                        if _save_experience(prompt, recipe, " -> ".join(tool_seq)):
+                            _log.info("经验已写入记忆库，随事件流提示")
+                            q.put(("step", {"tool": "🧠 经验记忆",
+                                            "args": "本轮操作已提炼为经验并写入记忆库"
+                                                    "（下次相似任务会自动参考）",
+                                            "image": None}))
+            except Exception as e:
+                _log.warning(f"经验保存异常: {e}")
+        q.put(("done", {"answer": answer}))
+    except Exception as e:
+        _log.warning(f"Agent 运行异常: {e}")
+        # 诊断：打印消息结构（tool_calls 与 tool 消息配对检查）
+        try:
+            roles = [m.get("role", "?") for m in agent.messages]
+            tcs = sum(1 for m in agent.messages
+                      if m.get("tool_calls") and isinstance(m.get("tool_calls"), list))
+            tools_msg = sum(1 for m in agent.messages if m.get("role") == "tool")
+            _log.warning(f"诊断 messages: {len(agent.messages)} 条 roles={roles[-8:]} "
+                         f"tool_calls消息={tcs} tool回应={tools_msg}")
+        except Exception:
+            pass
+        with _lock:
+            _run["state"] = "error"
+            _run["error"] = f"{type(e).__name__}: {str(e)[:200]}"
+        q.put(("error", {"message": str(e)[:200]}))
+    finally:
+        q.put(None)   # 关闭 SSE
+        _queues.pop(run_id, None)
+        _stop_events.pop(run_id, None)

web/apks_api.py

@@ -0,0 +1,123 @@
+"""应用管理 API（APK 上传/安装/删除/设备已装应用）。"""
+import re
+import shlex
+import subprocess
+
+from flask import Blueprint, jsonify, request
+from flask_login import login_required
+
+from core import device_pool
+from core.adb_helper import adb_connect_light, _adb
+from web import context
+from web.auth import perm_required, PERM_APKS
+from web.common import _merged_device_list
+
+bp = Blueprint("apks", __name__)
+
+@bp.route("/api/apks")
+@login_required
+def api_apks_list():
+    """列出所有已上传的 APK。"""
+    return jsonify({"ok": True, "apks": context.apk_mgr.list_all()})
+
+@bp.route("/api/apks/upload", methods=["POST"])
+@perm_required(PERM_APKS)
+def api_apks_upload():
+    """上传 APK 文件（multipart/form-data，字段名 file）。"""
+    file = request.files.get("file")
+    if not file or not file.filename:
+        return jsonify({"ok": False, "error": "未选择文件"}), 400
+    info = context.apk_mgr.upload(file)
+    if info:
+        return jsonify({"ok": True, "apk": info,
+                        "msg": f"上传成功: {info['display_name']}"})
+    return jsonify({"ok": False, "error": "上传失败，请检查文件格式"}), 500
+
+@bp.route("/api/apks/<apk_id>", methods=["DELETE"])
+@perm_required(PERM_APKS)
+def api_apks_delete(apk_id):
+    """删除 APK 文件和记录。"""
+    ok, msg = context.apk_mgr.delete(apk_id)
+    if ok:
+        return jsonify({"ok": True, "msg": msg})
+    return jsonify({"ok": False, "error": msg}), 400
+
+@bp.route("/api/apks/install/devices")
+@perm_required(PERM_APKS)
+def api_apks_install_devices():
+    """可安装设备列表（应用管理）：设备池在线设备 + 本机 adb 设备（含 USB 有线连接）。
+
+    source: pool=设备池 / usb=本机有线 adb / adb=本机网络 adb。
+    """
+    devices, seen = [], set()
+    try:
+        online = set(device_pool.list_online())
+        for serial in device_pool.list_configured():
+            if serial in online:
+                devices.append({"serial": serial, "model": "", "source": "pool"})
+                seen.add(serial)
+    except Exception:
+        pass
+    out = _adb("devices")
+    for line in (out or "").splitlines()[1:]:
+        parts = line.split()
+        if len(parts) >= 2 and parts[0] and parts[0] not in seen:
+            devices.append({"serial": parts[0], "model": "",
+                            "source": "usb" if ":" not in parts[0] else "adb"})
+            seen.add(parts[0])
+    return jsonify({"ok": True, "devices": devices})
+
+@bp.route("/api/apks/install", methods=["POST"])
+@perm_required(PERM_APKS)
+def api_apks_install():
+    """批量安装 APK 到指定设备。参数: {apk_id, serials:[]}"""
+    data = request.json or {}
+    apk_id = data.get("apk_id", "")
+    serials = data.get("serials", [])
+    ok, msg = context.apk_mgr.install(apk_id, serials)
+    if ok:
+        return jsonify({"ok": True, "msg": msg})
+    return jsonify({"ok": False, "error": msg}), 400
+
+@bp.route("/api/apks/install/status")
+@login_required
+def api_apks_install_status():
+    """获取安装任务实时状态。"""
+    status = context.apk_mgr.get_install_status()
+    return jsonify({"ok": True, "status": status})
+
+
+# ================== API：维护（仅管理员） ==================
+# 维护功能：STF 容器一键重启 + adb 远程终端。两个接口都仅管理员可用。
+# adb 终端安全红线（技术约束）：绝不 kill-server / 绝不 disconnect IP:5555——
+# STF provider 共享该 adb transport，断开会让 STF 误判全部设备离线并触发重连。
+_ADB_BLOCKED_PATTERNS = ("kill-server", "disconnect")
+
+
+def _blocked_adb_cmd(cmd):
+    """命中红线的 adb 命令（kill-server / disconnect）直接拒绝。"""
+    low = cmd.lower()
+    return any(p in low for p in _ADB_BLOCKED_PATTERNS)
+
+
+def _merged_device_list():
+    """本地 adb（含 USB）+ 设备池的合并列表（[{serial, state}]）。
+
+    供维护终端/剪贴板注入/应用版本管理等设备选择场景共用。
+    状态：device/offline=本机 adb 实际状态；pool=设备池已配置但本机未连接；
+    stf_not_ready=STF agent 未就绪（迁移期保留，阶段 3 摘除 STF 后删除）。
+    """
+    states = {}
+    out = _adb("devices")
+    for line in (out or "").splitlines()[1:]:
+        parts = line.split()
+        if len(parts) >= 2 and parts[0] and not parts[0].startswith("*"):
+            states[parts[0]] = parts[1]
+    try:
+        for serial in device_pool.list_configured():
+            if serial not in states:
+                states[serial] = "pool"
+    except Exception:
+        pass
+    return [{"serial": s, "state": st} for s, st in sorted(states.items())]
+

web/auth.py

@@ -0,0 +1,157 @@
+"""认证与页面路由：登录/登出/CSRF/权限装饰器/页面（/、/wall）。
+
+CSRF 的 before_request 由 web_server 注册（app 级），本模块提供实现。
+"""
+import functools
+import secrets
+
+from flask import (Blueprint, jsonify, request, redirect, url_for,
+                   render_template, make_response, session)
+from flask_login import (login_user, logout_user, login_required, current_user)
+
+from core.logger import get_logger
+from core.models import User
+
+_log = get_logger("web")
+
+bp = Blueprint("auth", __name__)
+
+
+# ================== CSRF ==================
+def _csrf_token():
+    """获取或生成当前会话的 CSRF token（非 GET 请求需在 X-CSRF-Token 头携带）。"""
+    if "csrf_token" not in session:
+        session["csrf_token"] = secrets.token_hex(16)
+    return session["csrf_token"]
+
+
+def _csrf_protect():
+    """非安全方法（POST/PUT/DELETE/PATCH）校验 X-CSRF-Token 请求头。"""
+    if request.method not in ("POST", "PUT", "DELETE", "PATCH"):
+        return
+    # 登录表单（未登录，尚无 token）和静态文件跳过
+    if request.endpoint in ("login", "static"):
+        return
+    sess = session.get("csrf_token", "")
+    header = request.headers.get("X-CSRF-Token", "")
+    if not sess or header != sess:
+        return jsonify({"ok": False, "error": "CSRF 校验失败"}), 403
+
+
+@bp.route("/api/csrf")
+@login_required
+def api_csrf():
+    """获取 CSRF token（前端非 GET 请求需携带 X-CSRF-Token 头）。"""
+    return jsonify({"ok": True, "token": _csrf_token()})
+
+
+# ================== 权限控制 ==================
+PERM_TASKS = "tasks"
+PERM_DEVICES = "devices"
+PERM_APKS = "apks"
+PERM_LOGS = "logs"
+ALL_PERMS = (PERM_TASKS, PERM_DEVICES, PERM_APKS, PERM_LOGS)
+_PERM_LABELS = {PERM_TASKS: "任务管理", PERM_DEVICES: "设备控制",
+                PERM_APKS: "应用管理", PERM_LOGS: "日志查看"}
+
+
+def _has_perm(perm):
+    """当前用户是否拥有指定权限。管理员恒为 True。"""
+    u = current_user
+    return bool(u and (u.is_admin or u.has_perm(perm)))
+
+
+def _validate_perms(raw):
+    """校验权限位列表：只保留合法值、去重。返回合法列表。"""
+    valid = set(ALL_PERMS)
+    out = []
+    for p in raw or []:
+        if p in valid and p not in out:
+            out.append(p)
+    return out
+
+
+def perm_required(perm):
+    """路由装饰器：要求登录且拥有指定业务权限，否则 403。"""
+    def deco(fn):
+        @functools.wraps(fn)
+        @login_required
+        def wrapper(*args, **kwargs):
+            if not _has_perm(perm):
+                return jsonify({"ok": False,
+                                "error": f"无权限执行此操作（需要权限: {_PERM_LABELS.get(perm, perm)}）"}), 403
+            return fn(*args, **kwargs)
+        return wrapper
+    return deco
+
+
+def admin_required(fn):
+    """路由装饰器：仅管理员可用（用户管理类接口），否则 403。"""
+    @functools.wraps(fn)
+    @login_required
+    def wrapper(*args, **kwargs):
+        if not current_user.is_admin:
+            return jsonify({"ok": False, "error": "仅管理员可执行此操作"}), 403
+        return fn(*args, **kwargs)
+    return wrapper
+
+
+@bp.route("/api/me")
+@login_required
+def api_me():
+    """当前登录用户信息（含权限位），前端据此隐藏无权限的功能入口。"""
+    u = current_user
+    return jsonify({"ok": True, "user": {
+        "id": u.id,
+        "username": u.username,
+        "is_admin": bool(u.is_admin),
+        # 管理员返回全部权限位，前端统一用 perms 判断
+        "perms": list(ALL_PERMS) if u.is_admin else u.get_perms(),
+    }})
+
+
+# ================== 页面路由 ==================
+@bp.route("/")
+@login_required
+def index():
+    """单页应用首页。"""
+    resp = make_response(render_template("admin/monitor.html"))
+    resp.headers["Cache-Control"] = "no-store, no-cache, must-revalidate, max-age=0"
+    resp.headers["Pragma"] = "no-cache"
+    return resp
+
+
+@bp.route("/wall")
+@login_required
+def wall():
+    """监控大屏（独立全屏页面，供挂墙/电视展示）。
+
+    深色控制室风格；设备缩略图按需轮询（每设备 ~5s 一帧），
+    20 台设备整体开销约 0.1 核 CPU + 50KB/s，普通电脑无压力。
+    """
+    resp = make_response(render_template("admin/wall.html"))
+    resp.headers["Cache-Control"] = "no-store, no-cache, must-revalidate, max-age=0"
+    return resp
+
+
+@bp.route("/login", methods=["GET", "POST"])
+def login():
+    if request.method == "POST":
+        username = request.form.get("username", "")
+        password = request.form.get("password", "")
+        user = User.query.filter_by(username=username).first()
+        if user and user.check_password(password):
+            login_user(user)
+            _csrf_token()  # 建立 CSRF token，前端通过 /api/csrf 获取
+            _log.info(f"用户 {username} 登录")
+            return redirect(request.args.get("next") or url_for("auth.index"))
+        return render_template("admin/login.html", error="用户名或密码错误")
+    return render_template("admin/login.html", error=None)
+
+
+@bp.route("/logout")
+@login_required
+def logout():
+    _log.info(f"用户 {current_user.username} 登出")
+    logout_user()
+    return redirect(url_for("auth.login"))

web/common.py

@@ -0,0 +1,46 @@
+"""跨模块共享工具（web 层）。"""
+from core import device_pool
+from core.adb_helper import _adb
+from core.logger import get_logger
+
+_log = get_logger("web")
+
+
+def _merged_device_list():
+    """本地 adb（含 USB）+ 设备池的合并列表（[{serial, state}]）。
+
+    供维护终端/剪贴板注入/应用版本管理等设备选择场景共用。
+    状态：device/offline=本机 adb 实际状态；pool=设备池已配置但本机未连接。
+    """
+    states = {}
+    out = _adb("devices")
+    for line in (out or "").splitlines()[1:]:
+        parts = line.split()
+        if len(parts) >= 2 and parts[0] and not parts[0].startswith("*"):
+            states[parts[0]] = parts[1]
+    try:
+        for serial in device_pool.list_configured():
+            if serial not in states:
+                states[serial] = "pool"
+    except Exception:
+        pass
+    return [{"serial": s, "state": st} for s, st in sorted(states.items())]
+
+
+def _device_screen_state(serial):
+    """设备屏幕状态：on/off/unknown（dumpsys power 只读查询）。
+
+    用 mWakefulness 判断（Asleep=熄屏）：MIUI 的 dumpsys display 没有
+    mScreenState 字段，power 字段全机型存在。USB 设备查询失败返回 unknown。
+    """
+    try:
+        if ":" not in serial:
+            return "unknown"
+        out = _adb("-s", serial, "shell", "dumpsys", "power") or ""
+        import re
+        m = re.search(r"mWakefulness=(\w+)", out)
+        if m:
+            return "off" if m.group(1).lower() == "asleep" else "on"
+    except Exception:
+        pass
+    return "unknown"

web/context.py

@@ -0,0 +1,12 @@
+"""共享上下文：web_server 启动时注入全局对象，各蓝图模块从这里取。
+
+避免蓝图模块与 web_server 循环 import。
+"""
+mgr = None          # core.task_manager.TaskManager
+apk_mgr = None      # core.apk_manager.ApkManager
+device_pool = None  # core.device_pool
+
+
+def init(mgr_, apk_mgr_, device_pool_):
+    global mgr, apk_mgr, device_pool
+    mgr, apk_mgr, device_pool = mgr_, apk_mgr_, device_pool_

web/devices_api.py

@@ -0,0 +1,237 @@
+"""设备池管理 API（本地 SQLite 清单）。"""
+import threading
+from concurrent.futures import ThreadPoolExecutor, as_completed
+
+from flask import Blueprint, jsonify, request
+
+from core import device_pool, device_discovery
+from core.adb_helper import adb_connect
+from core.logger import get_logger
+from web.auth import perm_required, PERM_DEVICES
+
+_log = get_logger("web")
+bp = Blueprint("devices", __name__)
+
+@bp.route("/api/devices/pool", methods=["GET"])
+@perm_required(PERM_DEVICES)
+def api_devices_pool_list():
+    """设备池清单（SQLite，含实时在线状态）。"""
+    try:
+        online = set(device_pool.list_online())
+    except Exception:
+        online = set()
+    rows = device_pool.list_devices()
+    for r in rows:
+        r["online"] = r["serial"] in online
+    return jsonify({"ok": True, "devices": rows})
+
+@bp.route("/api/devices/pool/add", methods=["POST"])
+@perm_required(PERM_DEVICES)
+def api_devices_pool_add():
+    """添加/更新设备：{serial, name?, note?}。
+
+    IP:5555 设备添加后立即尝试 adb connect（不可达显示离线，不影响其他设备）。
+    """
+    data = request.json or {}
+    serial = (data.get("serial") or "").strip()
+    if not serial:
+        return jsonify({"ok": False, "error": "请输入设备 serial（如 100.100.10.20:5555）"}), 400
+    is_new = device_pool.add_device(serial,
+                                    name=(data.get("name") or "").strip(),
+                                    note=(data.get("note") or "").strip())
+    msg = "已添加" if is_new else "已更新"
+    if ":" in serial:
+        try:
+            adb_connect(serial)
+        except Exception:
+            pass
+    # 后台采集型号（不阻塞添加响应）
+    import threading
+    threading.Thread(target=device_pool.refresh_model, args=(serial,),
+                     daemon=True).start()
+    _log.info(f"设备池管理: {msg} {serial}")
+    return jsonify({"ok": True, "msg": msg, "is_new": is_new})
+
+@bp.route("/api/devices/pool/remove", methods=["POST"])
+@perm_required(PERM_DEVICES)
+def api_devices_pool_remove():
+    """从设备池删除（不再参与调度；不影响其他系统）。"""
+    serial = (request.json or {}).get("serial", "").strip()
+    if not serial:
+        return jsonify({"ok": False, "error": "缺少 serial"}), 400
+    ok = device_pool.remove_device(serial)
+    if not ok:
+        return jsonify({"ok": False, "error": "设备不存在"}), 404
+    return jsonify({"ok": True, "msg": "已删除"})
+
+@bp.route("/api/devices/pool/toggle", methods=["POST"])
+@perm_required(PERM_DEVICES)
+def api_devices_pool_toggle():
+    """启用/停用设备（停用后不参与调度）。"""
+    data = request.json or {}
+    serial = (data.get("serial") or "").strip()
+    enabled = data.get("enabled")
+    if not serial or enabled is None:
+        return jsonify({"ok": False, "error": "缺少参数"}), 400
+    ok = device_pool.set_enabled(serial, bool(enabled))
+    if not ok:
+        return jsonify({"ok": False, "error": "设备不存在"}), 404
+    return jsonify({"ok": True, "msg": "已" + ("启用" if enabled else "停用")})
+
+@bp.route("/api/devices/pool/reconnect", methods=["POST"])
+@perm_required(PERM_DEVICES)
+def api_devices_pool_reconnect():
+    """一键重连：并发 adb connect 池内全部 IP:5555 设备（后台执行，不阻塞）。"""
+    def _run():
+        try:
+            serials = [s for s in device_pool.list_configured() if ":" in s]
+        except Exception:
+            return
+        if not serials:
+            return
+        from concurrent.futures import ThreadPoolExecutor, as_completed
+        with ThreadPoolExecutor(max_workers=10) as pool:
+            futures = {pool.submit(adb_connect, s): s for s in serials}
+            for _ in as_completed(futures):
+                pass
+        _log.info(f"设备池一键重连完成（{len(serials)} 台）")
+        # 重连后顺手刷新型号
+        try:
+            device_pool.refresh_all_models()
+        except Exception:
+            pass
+    import threading
+    threading.Thread(target=_run, daemon=True).start()
+    return jsonify({"ok": True, "msg": "重连已启动（后台并发，约 10-20 秒）"})
+
+@bp.route("/api/devices/pool/refresh_models", methods=["POST"])
+@perm_required(PERM_DEVICES)
+def api_devices_pool_refresh_models():
+    """批量采集池内在线设备的型号（后台执行，不阻塞）。"""
+    import threading
+    threading.Thread(target=device_pool.refresh_all_models, daemon=True).start()
+    return jsonify({"ok": True, "msg": "型号采集已启动（后台并发，约 10 秒）"})
+
+
+# ================== API：设备自动发现（扫描 → 待连接池 → 确认） ==================
+# 扫描只把设备放进待连接池（pending），用户确认后才加入正式设备池并连接。
+@bp.route("/api/devices/discovery", methods=["GET"])
+@perm_required(PERM_DEVICES)
+def api_devices_discovery():
+    """发现状态 + 待连接列表 + 正式池断联设备（前端 10s 轮询一次请求）。"""
+    try:
+        status = device_discovery.get_status()
+        pending = device_discovery.list_pending()
+        pool_offline = device_discovery.list_pool_offline()
+    except Exception as e:
+        _log.warning(f"discovery 状态获取失败: {e}")
+        return jsonify({"ok": False, "error": str(e)[:120]}), 503
+    status["pending"] = pending
+    status["pool_offline"] = pool_offline
+    return jsonify({"ok": True, **status})
+
+
+@bp.route("/api/devices/discovery/scan", methods=["POST"])
+@perm_required(PERM_DEVICES)
+def api_devices_discovery_scan():
+    """手动触发一轮扫描（后台执行，约 5-30 秒）。"""
+    ok, result = device_discovery.scan_once(manual=True)
+    if not ok:
+        return jsonify({"ok": False, "error": result.get("error", "扫描失败")}), 409
+    if "error" in result:
+        return jsonify({"ok": False, "error": result["error"]}), 400
+    return jsonify({"ok": True, "msg": "扫描已启动（后台执行，约 5-30 秒）",
+                    "result": result})
+
+
+@bp.route("/api/devices/discovery/confirm", methods=["POST"])
+@perm_required(PERM_DEVICES)
+def api_devices_discovery_confirm():
+    """确认连接：待连接 → 正式设备池 + 后台 adb connect + 采型号。"""
+    data = request.json or {}
+    serial = (data.get("serial") or "").strip()
+    if not serial:
+        return jsonify({"ok": False, "error": "缺少 serial"}), 400
+    ok, msg, is_new = device_discovery.confirm_pending(
+        serial, name=(data.get("name") or "").strip())
+    if not ok:
+        return jsonify({"ok": False, "error": msg}), 404
+    if ":" in serial:
+        def _connect():
+            try:
+                adb_connect(serial)
+            except Exception:
+                pass
+            try:
+                device_pool.refresh_model(serial)
+            except Exception:
+                pass
+        threading.Thread(target=_connect, daemon=True).start()
+    _log.info(f"设备池管理: 发现确认 {serial}")
+    return jsonify({"ok": True, "msg": msg, "is_new": is_new})
+
+
+@bp.route("/api/devices/discovery/ignore", methods=["POST"])
+@perm_required(PERM_DEVICES)
+def api_devices_discovery_ignore():
+    """忽略：从待连接池删除（下轮扫描可能再次发现）。"""
+    serial = (request.json or {}).get("serial", "").strip()
+    if not serial:
+        return jsonify({"ok": False, "error": "缺少 serial"}), 400
+    ok, msg = device_discovery.ignore_pending(serial)
+    if not ok:
+        return jsonify({"ok": False, "error": msg}), 404
+    return jsonify({"ok": True, "msg": msg})
+
+
+@bp.route("/api/devices/discovery/reconnect", methods=["POST"])
+@perm_required(PERM_DEVICES)
+def api_devices_discovery_reconnect():
+    """手动立即重连正式池断联设备（后台 adb connect + 采型号）。
+
+    日常无需手动——发现线程每轮（默认 60s）自动重连断联设备；
+    本端点用于不想等下一轮扫描时立即拉起。
+    """
+    serial = (request.json or {}).get("serial", "").strip()
+    if not serial:
+        return jsonify({"ok": False, "error": "缺少 serial"}), 400
+    from core import device_pool
+    if serial not in device_pool.list_configured():
+        return jsonify({"ok": False, "error": "设备不在设备池中"}), 404
+
+    def _reconnect():
+        try:
+            if ":" in serial:
+                adb_connect(serial)
+            # 无论是否连上，采一次型号（模型失败静默）
+            try:
+                device_pool.refresh_model(serial)
+            except Exception:
+                pass
+        except Exception as e:
+            _log.warning(f"手动重连 {serial} 异常: {e}")
+
+    threading.Thread(target=_reconnect, daemon=True).start()
+    _log.info(f"设备池管理: 手动重连 {serial}")
+    return jsonify({"ok": True, "msg": "重连已启动（约 5-15 秒生效）"})
+
+
+@bp.route("/api/devices/discovery/settings", methods=["POST"])
+@perm_required(PERM_DEVICES)
+def api_devices_discovery_settings():
+    """保存发现配置（部分字段更新）：{enabled?, subnets?, interval?, port?}。"""
+    data = request.json or {}
+    ok, msg = device_discovery.save_settings(
+        enabled=data.get("enabled"),
+        subnets=data.get("subnets"),
+        interval=data.get("interval"),
+        port=data.get("port"))
+    if not ok:
+        return jsonify({"ok": False, "error": msg}), 400
+    return jsonify({"ok": True, "msg": msg})
+
+
+# ================== API：Tailscale 管理（仅管理员） ==================
+# 通过 Tailscale 官方 API v2 管理 tailnet 设备（列表/改名/授权/密钥不过期/删除/生成 auth key）。
+# 设备 IP 由 tailnet 自动分配，API 无法修改，列表只读展示。
+

web/index.html

@@ -1,94 +0,0 @@
-<!DOCTYPE html>
-<html lang="zh-CN"><head><meta charset="UTF-8"><title>设备监控大屏</title>
-<style>
-  *{box-sizing:border-box} body{font-family:-apple-system,"Segoe UI",Roboto,sans-serif;margin:0;background:#f0f2f5;color:#2c3e50}
-  .header{background:#fff;padding:14px 24px;box-shadow:0 1px 4px rgba(0,0,0,.08);display:flex;align-items:center;gap:16px}
-  .header h1{font-size:18px;margin:0} .header .ts{color:#95a5a6;font-size:12px;margin-left:auto}
-  .header a{color:#1890ff;text-decoration:none;font-size:13px}
-  .header a:hover{text-decoration:underline}
-  .content{padding:20px 24px;max-width:1400px;margin:0 auto}
-  .bar{display:flex;gap:8px;margin-bottom:16px;align-items:center;flex-wrap:wrap}
-  button{padding:7px 16px;border:1px solid #d9d9d9;border-radius:4px;cursor:pointer;font-size:13px;background:#fff;color:#595959}
-  button:hover{border-color:#40a9ff;color:#40a9ff} button.primary{background:#1890ff;color:#fff;border-color:#1890ff}
-  button.primary:hover{background:#40a9ff} button.danger{color:#ff4d4f;border-color:#ff4d4f}
-  button.danger:hover{background:#ff4d4f;color:#fff} button.sm{padding:3px 10px;font-size:12px}
-  table{width:100%;border-collapse:collapse;background:#fff;border-radius:6px;overflow:hidden;box-shadow:0 1px 3px rgba(0,0,0,.08)}
-  th,td{padding:9px 10px;text-align:left;border-bottom:1px solid #f0f0f0;font-size:13px}
-  th{background:#fafafa;font-weight:600;color:#595959} tr:hover td{background:#fafafa}
-  .badge{padding:2px 8px;border-radius:10px;font-size:11px;color:#fff}
-  .b-running{background:#52c41a}.b-connecting{background:#faad14}.b-error{background:#ff4d4f}
-  .b-done{background:#1890ff}.b-idle{background:#bfbfbf;color:#595959}.b-released{background:#8c8c8c}.b-failed{background:#ff4d4f}
-  .ok{color:#52c41a}.no{color:#ff4d4f}.muted{color:#8c8c8c;font-size:12px}
-  .err{color:#ff4d4f;font-size:12px;max-width:180px;overflow:hidden;text-overflow:ellipsis;white-space:nowrap}
-  .progress{width:70px;height:5px;background:#f0f0f0;border-radius:3px;overflow:hidden;display:inline-block;vertical-align:middle}
-  .progress>div{height:100%;background:#1890ff}
-  .tag{display:inline-block;background:#e6f7ff;color:#1890ff;padding:1px 8px;border-radius:3px;font-size:11px;margin:1px}
-  .kv{display:inline-block;background:#f5f5f5;border-radius:3px;padding:0 6px;margin:1px;font-size:11px;color:#595959}
-  .stats{display:flex;gap:16px;margin-bottom:16px}
-  .stat-card{background:#fff;padding:14px 20px;border-radius:6px;box-shadow:0 1px 3px rgba(0,0,0,.08);min-width:120px}
-  .stat-card .num{font-size:24px;font-weight:600;color:#1890ff}
-  .stat-card .lbl{font-size:12px;color:#8c8c8c;margin-top:2px}
-</style></head><body>
-<div class="header">
-  <h1>设备监控大屏</h1>
-  <span class="muted" id="devCount"></span>
-  <span class="ts" id="srvTime"></span>
-  <a href="/admin" target="_blank">管理后台 →</a>
-</div>
-<div class="content">
-  <div class="stats" id="stats"></div>
-  <div class="bar">
-    <button class="primary" onclick="doPost('/api/jobs/_quick/run')" title="快速启动：对全部空闲设备跑默认抖音养号">快速启动全部</button>
-    <button class="danger" onclick="doPost('/api/stop_all')">停止全部</button>
-    <button onclick="doPost('/api/release')">强制释放占用</button>
-    <button onclick="loadStatus()">刷新</button>
-    <span class="muted">每 5 秒自动刷新 · 分组/任务管理请到 <a href="/admin" target="_blank">管理后台</a></span>
-  </div>
-  <table><thead><tr>
-    <th>设备</th><th>型号</th><th>STF</th><th>任务状态</th><th>抖音</th><th>进度</th>
-    <th>任务名称</th><th>当前动作</th><th>操作计数</th><th>最近错误</th><th>操作</th>
-  </tr></thead><tbody id="tb-devices"></tbody></table>
-</div>
-<script>
-const ACTION_LABELS={like:'点赞',comment:'评论',follow:'关注',share:'分享'};
-function doPost(url,body){return fetch(url,{method:'POST',headers:{'Content-Type':'application/json'},body:body?JSON.stringify(body):'{}'}).then(r=>r.json()).then(d=>{alert(JSON.stringify(d,null,1));loadStatus();}).catch(e=>alert(e));}
-function fmtActionCounts(c){
-  if(!c||!Object.keys(c).length)return '<span class="muted">-</span>';
-  const parts=Object.entries(c).filter(([_,v])=>v>0).map(([k,v])=>'<span class="kv">'+(ACTION_LABELS[k]||k)+v+'</span>');
-  return parts.length?parts.join(''):'<span class="muted">-</span>';
-}
-async function loadStatus(){
-  try{
-    const r=await fetch('/api/status');const d=await r.json();if(!d.ok)return;
-    document.getElementById('devCount').textContent='设备 '+d.devices.length;
-    document.getElementById('srvTime').textContent=new Date(d.server_time*1000).toLocaleTimeString();
-    // 统计卡片
-    const running=d.devices.filter(x=>x.worker_status==='running').length;
-    const idle=d.devices.filter(x=>x.worker_status==='idle').length;
-    const error=d.devices.filter(x=>['error','failed'].includes(x.worker_status)).length;
-    const occupied=d.devices.filter(x=>x.stf_occupied).length;
-    document.getElementById('stats').innerHTML=
-      '<div class="stat-card"><div class="num" style="color:#52c41a">'+running+'</div><div class="lbl">运行中</div></div>'+
-      '<div class="stat-card"><div class="num" style="color:#1890ff">'+occupied+'</div><div class="lbl">STF占用</div></div>'+
-      '<div class="stat-card"><div class="num" style="color:#bfbfbf">'+idle+'</div><div class="lbl">空闲</div></div>'+
-      '<div class="stat-card"><div class="num" style="color:#ff4d4f">'+error+'</div><div class="lbl">异常</div></div>';
-    // 设备表格
-    document.getElementById('tb-devices').innerHTML=d.devices.map(dev=>{
-      const stf=dev.stf_occupied?'<span class="badge b-running">占用</span>':'<span class="badge b-idle">空闲</span>';
-      if(!dev.present)stf+=' <span class="no">离线</span>';
-      const ws=dev.worker_status;
-      const wb='<span class="badge b-'+ws+'">'+({idle:'未启动',connecting:'连接中',running:'运行中',done:'完成',error:'异常',released:'已释放',failed:'失败'}[ws]||ws)+'</span>';
-      const dy=dev.douyin_running?'<span class="ok">●</span>':'<span class="no">○</span>';
-      const pct=Math.round(dev.videos_watched/80*100);
-      const prog='<span class="progress"><div style="width:'+pct+'%"></div></span> '+dev.videos_watched;
-      const tname=dev.task_job?'<span class="tag">'+dev.task_job+'</span>':'<span class="muted">-</span>';
-      const retry=dev.attempt>0?' <span class="muted">'+dev.attempt+'次</span>':'';
-      const btn=dev.worker_status==='running'||dev.worker_status==='connecting'?'<button class="danger sm" onclick="doPost(\'/api/stop_device\',{serial:\''+dev.serial+'\'})">停止</button>':'';
-      return '<tr><td>'+dev.serial+'</td><td>'+dev.model+'</td><td>'+stf+'</td><td>'+wb+'</td><td>'+dy+'</td><td>'+prog+'</td><td>'+tname+retry+'</td><td class="muted">'+(dev.current_action||'-')+'</td><td>'+fmtActionCounts(dev.action_counts)+'</td><td class="err" title="'+(dev.last_error||'')+'">'+(dev.last_error||'-')+'</td><td>'+btn+'</td></tr>';
-    }).join('');
-  }catch(e){console.error(e);}
-}
-loadStatus();
-setInterval(loadStatus,5000);
-</script>
-</body></html>

web/monitor.py

@@ -0,0 +1,701 @@
+"""监控域 API：状态/运行控制/设备操作/远程看屏。"""
+import time
+import threading
+import re
+import subprocess
+import shlex
+from concurrent.futures import ThreadPoolExecutor, as_completed
+
+from flask import (Blueprint, jsonify, request, Response, render_template)
+from flask_login import login_required
+
+from core import device_pool
+from core.adb_helper import (screenshot, list_installed_apps, adb_connect,
+                             adb_connect_light, _ADB_LOCK, _adb)
+from core.device_worker import (get_all_worker_status, clear_worker_error,
+                             clear_all_worker_errors)
+from web import context
+from web.auth import perm_required, PERM_DEVICES
+from web.common import _merged_device_list, _device_screen_state
+from config import ADB_PATH
+from core.logger import get_logger
+
+_log = get_logger("web")
+
+bp = Blueprint("monitor", __name__)
+
+# 远程看屏参数
+_SCREEN_JPEG_QUALITY = 65
+_SCREEN_FRAME_GAP = 0.05
+
+@bp.route("/api/health")
+def api_health():
+    """轻量健康检查：返回进程/设备/任务摘要，不暴露敏感信息，供运维探活。"""
+    try:
+        devices, err = context.mgr.get_status()
+        devs = devices or []
+        return jsonify({
+            "ok": True,
+            "status": "up",
+            "time": time.time(),
+            "device_total": len(devs),
+            "device_online": sum(1 for d in devs if d.get("present")),
+            "device_running": sum(1 for d in devs
+                                  if d.get("worker_status") in ("running", "connecting")),
+            "device_error": sum(1 for d in devs
+                                if d.get("worker_status") in ("error", "failed")),
+            "jobs": len(context.mgr.jobs),
+        })
+    except Exception as e:
+        return jsonify({"ok": False, "status": "down", "error": str(e)}), 500
+
+
+# ================== API：失败任务汇总 ==================
+
+@bp.route("/api/summary")
+@login_required
+def api_summary():
+    """失败/异常任务汇总：各状态计数 + 异常设备列表（last_error / 重试次数）。
+
+    供监控页"异常汇总"面板使用，便于长期运行观察设备健康度。
+    """
+    try:
+        sts = get_all_worker_status()
+        # 已删除/不在当前 STF 设备池的设备，其陈旧失败记录不应展示。
+        # 复用 get_status 缓存（顺带触发上面的状态清理），STF 异常时不隐藏任何记录。
+        try:
+            devices, derr = context.mgr.get_status()
+            if not derr:
+                present = {d.get("serial") for d in devices}
+                sts = [s for s in sts if s.get("serial") in present]
+        except Exception:
+            pass
+        counts = {"total": 0, "running": 0, "done": 0,
+                  "error": 0, "failed": 0, "idle": 0}
+        errors = []
+        for s in sts:
+            st = s.get("status", "idle")
+            counts["total"] += 1
+            if st in counts:
+                counts[st] += 1
+            if st in ("error", "failed") and s.get("last_error"):
+                errors.append({
+                    "serial": s.get("serial"),
+                    "model": s.get("model", ""),
+                    "status": st,
+                    "last_error": s.get("last_error", ""),
+                    "task": s.get("task_job", ""),
+                    "attempt": s.get("attempt", 0),
+                    "updated": s.get("last_heartbeat", 0),
+                })
+        errors.sort(key=lambda x: x.get("updated", 0), reverse=True)
+        return jsonify({"ok": True, "counts": counts, "errors": errors[:50]})
+    except Exception as e:
+        return jsonify({"ok": False, "error": str(e)}), 500
+
+
+# ================== API：状态（监控大屏用）==================
+
+@bp.route("/api/status")
+@login_required
+def api_status():
+    devices, err = context.mgr.get_status()
+    if err:
+        return jsonify({"ok": False, "error": err}), 500
+    return jsonify({
+        "ok": True, "devices": devices, "server_time": time.time(),
+        "fg_scanning": context.mgr._fg_scanner.is_scanning,
+        "fg_last_scan": context.mgr._fg_scanner.last_scan_time,
+    })
+
+@bp.route("/api/scan_foreground", methods=["POST"])
+@perm_required(PERM_DEVICES)
+def api_scan_foreground():
+    """手动触发前台 App 扫描（不打扰设备）。"""
+    started = context.mgr._fg_scanner.scan_once()
+    if started:
+        return jsonify({"ok": True, "msg": "扫描已启动"})
+    return jsonify({"ok": False, "error": "已有扫描在进行中"})
+
+@bp.route("/api/stop_device", methods=["POST"])
+@perm_required(PERM_DEVICES)
+def api_stop_device():
+    serial = (request.json or {}).get("serial", "")
+    if context.mgr.stop_device(serial):
+        return jsonify({"ok": True, "msg": f"已发送停止信号给 {serial}"})
+    return jsonify({"ok": False, "error": f"{serial} 没有运行中的任务"}), 400
+
+@bp.route("/locate")
+def locate_page():
+    """设备端定位页（免登录）：点亮后浏览器打开，大字显示设备 IP/序列号。
+
+    只展示 serial 文本，无任何平台数据，免登录可接受。
+    """
+    serial = request.args.get("serial", "")
+    return render_template_string(
+        """<!DOCTYPE html><html><head><meta charset="utf-8">
+<meta name="viewport" content="width=device-width,initial-scale=1">
+<title>设备定位</title><style>
+body{margin:0;background:#000;color:#fff;display:flex;flex-direction:column;
+align-items:center;justify-content:center;height:100vh;font-family:monospace}
+.serial{font-size:min(9vw,72px);font-weight:700;color:#ffd700;word-break:break-all;padding:0 20px;text-align:center}
+.ip{font-size:min(5vw,36px);color:#7dd3fc;margin-top:24px;word-break:break-all;padding:0 20px;text-align:center}
+.hint{font-size:min(3vw,16px);color:#64748b;margin-top:40px}
+</style></head><body>
+<div class="serial">{{ serial }}</div>
+<div class="ip">{{ ip }}</div>
+<div class="hint">定位完成 · 按返回键退出</div>
+</body></html>""",
+        serial=_esc(serial), ip=_esc(serial.split(":")[0]))
+
+
+# 常见浏览器包名（结束定位时 force-stop 用）
+_BROWSER_PKGS = {"com.android.browser", "com.miui.browser", "com.android.chrome",
+                 "com.brave.browser", "com.opera.browser", "org.mozilla.firefox",
+                 "com.UCMobile", "com.tencent.mtt", "com.baidu.browser.apps"}
+# 定位时启动的浏览器：serial -> 包名（结束定位时无论前后台都关闭它）
+_locate_browsers = {}
+_locate_lock = threading.Lock()
+
+
+def _current_focus_pkg(serial):
+    """取设备当前前台包名（dumpsys window 解析，失败返回空串）。"""
+    try:
+        r = subprocess.run([ADB_PATH, "-s", serial, "shell", "dumpsys", "window"],
+                           capture_output=True, timeout=20)
+        out = (r.stdout or b"").decode("utf-8", errors="replace")
+        m = re.search(r"mCurrentFocus=.*?([\w.]+)/", out)
+        return m.group(1) if m else ""
+    except Exception:
+        return ""
+
+@bp.route("/api/device/locate/stop", methods=["POST"])
+@perm_required(PERM_DEVICES)
+def api_device_locate_stop():
+    """结束定位：关闭定位启动的浏览器（无论当前是否前台）。
+
+    优先 force-stop 定位时记录下的浏览器包名（切到后台也能关掉）；
+    无记录时退回：前台是浏览器 → force-stop；否则按返回键（不误杀任务应用）。
+    """
+    serial = str((request.json or {}).get("serial", "")).strip()
+    if not serial:
+        return jsonify({"ok": False, "error": "缺少设备 serial"}), 400
+    try:
+        if ":" in serial:
+            adb_connect(serial)
+        # 1. 优先关闭定位时启动的浏览器（无论前后台）
+        with _locate_lock:
+            started = _locate_browsers.pop(serial, None)
+        if started:
+            subprocess.run([ADB_PATH, "-s", serial, "shell", "am", "force-stop", started],
+                           capture_output=True, timeout=20)
+            msg = f"已关闭定位浏览器 {started}"
+        else:
+            # 2. 退回：前台是浏览器则关闭，否则返回键轻量退出
+            pkg = _current_focus_pkg(serial)
+            if pkg in _BROWSER_PKGS:
+                subprocess.run([ADB_PATH, "-s", serial, "shell", "am", "force-stop", pkg],
+                               capture_output=True, timeout=20)
+                msg = f"已关闭浏览器 {pkg}"
+            else:
+                subprocess.run([ADB_PATH, "-s", serial, "shell", "input", "keyevent", "4"],
+                               capture_output=True, timeout=15)  # BACK 轻量退出
+                msg = "已按返回键退出" + (f"（前台 {pkg}）" if pkg else "")
+        _log.info(f"结束定位 {serial}: {msg}")
+        return jsonify({"ok": True, "msg": msg})
+    except Exception as e:
+        return jsonify({"ok": False, "error": f"结束定位失败: {e}"}), 502
+
+@bp.route("/api/device/screen_all", methods=["POST"])
+@perm_required(PERM_DEVICES)
+def api_device_screen_all():
+    """批量亮屏/息屏（并发）。mode: on=亮屏解锁 / off=息屏。
+
+    请求可带 serials 指定设备（前端勾选）；不带则作用于全部在线设备。
+    息屏会中断运行中的任务（u2 无法操作），前端已有确认提示。
+    """
+    data = request.json or {}
+    mode = data.get("mode", "on")
+    try:
+        online = set(device_pool.list_online())
+    except Exception as e:
+        return jsonify({"ok": False, "error": f"获取设备列表失败: {e}"}), 502
+    serials = data.get("serials") or []
+    if serials:
+        # 指定设备：过滤掉不在线的（离线设备操作无意义，直接跳过）
+        serials = [s for s in serials if s in online]
+    else:
+        serials = list(online)
+    if not serials:
+        return jsonify({"ok": False, "error": "无在线设备"}), 400
+
+    def _do(serial):
+        try:
+            if ":" in serial:
+                adb_connect(serial)
+            if mode == "off":
+                subprocess.run([ADB_PATH, "-s", serial, "shell", "input", "keyevent", "26"],
+                               capture_output=True, timeout=15)  # KEYCODE_POWER 息屏
+            else:
+                subprocess.run([ADB_PATH, "-s", serial, "shell", "input", "keyevent", "224"],
+                               capture_output=True, timeout=15)  # WAKEUP
+                subprocess.run([ADB_PATH, "-s", serial, "shell", "wm", "dismiss-keyguard"],
+                               capture_output=True, timeout=15)
+            return True
+        except Exception:
+            return False
+
+    with ThreadPoolExecutor(max_workers=min(10, len(serials))) as pool:
+        results = list(pool.map(_do, serials))
+    ok_n = sum(1 for x in results if x)
+    _log.info(f"批量{'息屏' if mode == 'off' else '亮屏'}: 成功 {ok_n}/{len(serials)}")
+    return jsonify({"ok": True, "success": ok_n, "total": len(serials)})
+
+@bp.route("/api/device/locate", methods=["POST"])
+@perm_required(PERM_DEVICES)
+def api_device_locate():
+    """定位设备：点亮屏幕并解除锁屏，可选打开大字定位页（查找设备用）。
+
+    请求 {"serial": "...", "show": true}：show=true 时额外用浏览器打开
+    平台 /locate 定位页，全屏大字显示设备 IP（更醒目，但会切换前台，
+    任务运行中慎用）。点亮组合：WAKEUP → dismiss-keyguard → MENU 兜底。
+    绝不 disconnect，红线。
+    """
+    data = request.json or {}
+    serial = str(data.get("serial", "")).strip()
+    if not serial:
+        return jsonify({"ok": False, "error": "缺少设备 serial"}), 400
+    try:
+        if ":" in serial:
+            adb_connect(serial)
+        for cmd in (["shell", "input", "keyevent", "224"],
+                    ["shell", "wm", "dismiss-keyguard"],
+                    ["shell", "input", "keyevent", "82"]):
+            try:
+                subprocess.run([ADB_PATH, "-s", serial, *cmd],
+                               capture_output=True, timeout=15)
+            except Exception:
+                pass  # 单步失败不阻塞，继续下一步
+        msgs = ["屏幕已点亮"]
+        if data.get("show"):
+            # 用设备浏览器打开定位页（设备走 tailnet 访问本机 100.100.10.2:18050）
+            locate_url = f"http://100.100.10.2:18050/locate?serial={urllib.parse.quote(serial)}"
+            r = subprocess.run([ADB_PATH, "-s", serial, "shell", "am", "start",
+                                "-a", "android.intent.action.VIEW", "-d", locate_url],
+                               capture_output=True, timeout=20)
+            out = ((r.stdout or b"") + (r.stderr or b"")).decode("utf-8", errors="replace")
+            if "error" in out.lower() or "exception" in out.lower():
+                msgs.append(f"打开定位页失败: {out.strip()[:80]}")
+            else:
+                msgs.append("已打开大字定位页（按返回键退出）")
+                # 记录启动的浏览器包名：结束定位时无论前后台都关闭它。
+                # 优先从 am start 输出解析 pkg=（浏览器可能尚未到前台，前台检测会扑空）
+                pkg = ""
+                m2 = re.search(r"pkg=([\w.]+)", out)
+                if m2 and m2.group(1) in _BROWSER_PKGS:
+                    pkg = m2.group(1)
+                else:
+                    time.sleep(1.5)  # 等浏览器切到前台再查
+                    pkg = _current_focus_pkg(serial)
+                if pkg in _BROWSER_PKGS:
+                    with _locate_lock:
+                        _locate_browsers[serial] = pkg
+        _log.info(f"定位设备 {serial}: {'; '.join(msgs)}")
+        return jsonify({"ok": True, "msg": f"{serial} {'；'.join(msgs)}"})
+    except Exception as e:
+        return jsonify({"ok": False, "error": f"定位失败: {e}"}), 502
+
+@bp.route("/api/stop_all", methods=["POST"])
+@perm_required(PERM_DEVICES)
+def api_stop_all():
+    stopped = context.mgr.stop_all()
+    return jsonify({"ok": True, "stopped": stopped})
+
+@bp.route("/api/device/clear_error", methods=["POST"])
+@perm_required(PERM_DEVICES)
+def api_device_clear_error():
+    """清除单台设备的异常状态（error/failed → idle），供设备列表"清除异常"按钮使用。"""
+    serial = (request.json or {}).get("serial", "")
+    if not serial:
+        return jsonify({"ok": False, "error": "缺少 serial"}), 400
+    if serial in context.mgr.get_running():
+        return jsonify({"ok": False, "error": "设备正在运行或等待重试，无法清除"}), 400
+    if not clear_worker_error(serial):
+        return jsonify({"ok": False, "error": "设备正在运行任务，无法清除"}), 400
+    _log.info(f"清除设备 {serial} 的异常状态")
+    return jsonify({"ok": True, "msg": f"已清除 {serial} 的异常状态"})
+
+@bp.route("/api/device/clear_all_errors", methods=["POST"])
+@perm_required(PERM_DEVICES)
+def api_device_clear_all_errors():
+    """一键清除所有异常/失败设备（跳过正在运行/等待重试的）。"""
+    running = set(context.mgr.get_running())
+    cleared = clear_all_worker_errors(exclude=running)
+    _log.info(f"一键清除异常：共清除 {cleared} 台")
+    return jsonify({"ok": True, "cleared": cleared,
+                    "msg": f"已清除 {cleared} 台设备的异常状态"})
+
+@bp.route("/api/device/screenshot")
+@login_required
+def api_device_screenshot():
+    """获取设备当前画面截图（PNG）。
+
+    用 adb exec-out screencap -p，只读操作，不抢占 u2 的 atx-agent 通道，
+    任务运行中调用安全。直接返回 image/png，前端用 <img> 加载。
+    ?serial=xxx  设备 serial
+    ?t=123       时间戳，避免浏览器缓存（前端自动加）
+    """
+    serial = request.args.get("serial", "")
+    if not serial:
+        return jsonify({"ok": False, "error": "缺少 serial"}), 400
+    ok, data = screenshot(serial)
+    if ok:
+        return Response(data, mimetype="image/png",
+                        headers={"Cache-Control": "no-store"})
+    return jsonify({"ok": False, "error": data}), 500
+
+@bp.route("/api/devices/<serial>/apps")
+@login_required
+def api_device_apps(serial):
+    """获取指定设备上已安装的应用列表（包名 + versionCode + versionName + 路径）。"""
+    ok, data = list_installed_apps(serial)
+    if ok:
+        return jsonify({"ok": True, "apps": data})
+    return jsonify({"ok": False, "error": data}), 500
+
+
+# ================== 自定义动作（步骤打包） ==================
+
+@bp.route("/api/screen/stream")
+@perm_required(PERM_DEVICES)
+def api_screen_stream():
+    """远程看屏：MJPEG 实时画面流（multipart/x-mixed-replace）。
+
+    ?serial=xxx  设备 serial
+    浏览器 <img> 直接渲染；客户端断开（GeneratorExit）自动停止，不占资源。
+    设备离线/atx-agent 无响应时流自然结束，前端提示重新连接。
+    """
+    serial = request.args.get("serial", "")
+    if not serial:
+        return jsonify({"ok": False, "error": "缺少 serial"}), 400
+
+    # 参数：q=JPEG 质量（大屏弹窗用 85 更清晰）；fps=目标帧率（0=默认节流）
+    try:
+        quality = max(30, min(95, int(request.args.get("q", _SCREEN_JPEG_QUALITY))))
+        fps = float(request.args.get("fps", 0) or 0)
+    except ValueError:
+        quality, fps = _SCREEN_JPEG_QUALITY, 0
+    gap = (1.0 / fps) if fps > 0 else _SCREEN_FRAME_GAP
+
+    def generate():
+        import io
+        import uiautomator2 as u2
+        try:
+            d = u2.connect(serial)
+        except Exception as e:
+            _log.warning(f"远程看屏 {serial} u2 连接失败: {e}")
+            return
+        while True:
+            try:
+                img = d.screenshot()
+                if img is None:
+                    break
+                if img.mode != "RGB":
+                    img = img.convert("RGB")
+                buf = io.BytesIO()
+                img.save(buf, "JPEG", quality=quality)
+                yield (b"--frame\r\nContent-Type: image/jpeg\r\n\r\n"
+                       + buf.getvalue() + b"\r\n")
+            except GeneratorExit:
+                break
+            except Exception as e:
+                _log.debug(f"远程看屏 {serial} 流中断: {e}")
+                break
+            time.sleep(gap)
+
+    return Response(generate(),
+                    mimetype="multipart/x-mixed-replace; boundary=frame")
+
+
+_screen_u2_cache = {}  # serial -> (ts, device)：大屏高频触控复用连接（60s TTL）
+
+
+def _screen_get_device(serial):
+    """远程看屏用的 u2 连接（60s 缓存复用，避免每次 tap/swipe 都重建连接）。
+
+    大屏高频操作（点击/滑动/按键）每次 u2.connect 有 1-3s 握手开销（atx-agent
+    探测），体验卡顿。缓存 60s 内复用；连接失败（设备离线/重启）时清缓存重建，
+    由调用方把异常转 503。
+    """
+    import time
+    import uiautomator2 as u2
+    now = time.time()
+    cached = _screen_u2_cache.get(serial)
+    if cached and now - cached[0] < 60:
+        return cached[1]
+    d = u2.connect(serial)
+    _screen_u2_cache[serial] = (now, d)
+    if len(_screen_u2_cache) > 30:  # 惰性清理过期项
+        for k in list(_screen_u2_cache):
+            if now - _screen_u2_cache[k][0] >= 60:
+                del _screen_u2_cache[k]
+    return d
+
+
+def _screen_invalidate(serial):
+    """u2 调用失败时清掉缓存（设备离线/atx-agent 重启），下次请求重新连接。"""
+    _screen_u2_cache.pop(serial, None)
+
+@bp.route("/api/screen/thumb")
+@perm_required(PERM_DEVICES)
+def api_screen_thumb():
+    """大屏缩略图：单张 JPEG（360px 宽，质量 55），供监控大屏轮询。
+
+    一次性请求（非流），与任务并发安全（与任务截图同走 u2 minicap）。
+    大屏按需轮询：每设备约 2.5s 一帧，20 台 ≈ 0.2 核 CPU + 100KB/s。
+    响应头 X-Screen-State: on/off/unknown —— 大屏据此显示「亮屏中/熄屏中」。
+    """
+    serial = request.args.get("serial", "")
+    if not serial:
+        return jsonify({"ok": False, "error": "缺少 serial"}), 400
+    import io
+    import uiautomator2 as u2
+    try:
+        d = u2.connect(serial)
+        img = d.screenshot()
+        if img is None:
+            return jsonify({"ok": False, "error": "截图失败"}), 503
+        if img.width > 360:
+            ratio = 360 / img.width
+            img = img.resize((360, int(img.height * ratio)))
+        buf = io.BytesIO()
+        img.convert("RGB").save(buf, "JPEG", quality=55)
+        return Response(buf.getvalue(), mimetype="image/jpeg",
+                        headers={"Cache-Control": "no-store",
+                                 "X-Screen-State": _device_screen_state(serial)})
+    except Exception as e:
+        return jsonify({"ok": False, "error": str(e)}), 503
+
+
+def _snap_to_clickable(d, x, y):
+    """坐标吸附：找包含 (x,y) 的最小可点击元素，返回其 bounds 中心。
+
+    AI/触控给的坐标常偏离目标 20-50px（模型视觉定位误差）。dump 当前 UI 树后
+    遍历 clickable 节点：点击点落在哪个可点元素内就点它的中心——偏了也点得准；
+    取包含元素中面积最小者（最具体的那个）。点空白处（收键盘等）无包含元素则
+    原坐标返回。dump 失败也不阻塞，直接原坐标。返回 (cx, cy, snapped, label)。
+    """
+    try:
+        import xml.etree.ElementTree as ET
+        xml_str = d.dump_hierarchy()
+        best = None  # (area, cx, cy, label)
+        for node in ET.fromstring(xml_str).iter("node"):
+            if node.get("clickable") != "true":
+                continue
+            if node.get("enabled") == "false":
+                continue
+            m = re.match(r"\[(\d+),(\d+)\]\[(\d+),(\d+)\]", node.get("bounds", ""))
+            if not m:
+                continue
+            x1, y1, x2, y2 = map(int, m.groups())
+            if x1 <= x <= x2 and y1 <= y <= y2:
+                area = (x2 - x1) * (y2 - y1)
+                if best is None or area < best[0]:
+                    best = (area, (x1 + x2) // 2, (y1 + y2) // 2,
+                            (node.get("text") or node.get("content-desc") or "")[:40])
+        if best:
+            return best[1], best[2], True, best[3]
+    except Exception:
+        pass
+    return x, y, False, ""
+
+
+@bp.route("/api/screen/tap", methods=["POST"])
+@perm_required(PERM_DEVICES)
+def api_screen_tap():
+    """点击：{serial, x, y, snap?}（设备原生分辨率坐标）。
+
+    snap=1 时先吸附：点落在可点击元素内则改点元素中心（MCP/AI 场景用，粗略
+    坐标也能点准）；大屏精确触控不带 snap 保持原行为。
+    返回 {ok, snapped, x, y, label}。
+    """
+    data = request.json or {}
+    serial, x, y = data.get("serial", ""), data.get("x"), data.get("y")
+    snap = int(data.get("snap", 0) or 0) == 1
+    if not serial or x is None or y is None:
+        return jsonify({"ok": False, "error": "缺少 serial/x/y"}), 400
+    try:
+        d = _screen_get_device(serial)
+        sx, sy = int(x), int(y)
+        label = ""
+        snapped = False
+        if snap:
+            sx, sy, snapped, label = _snap_to_clickable(d, sx, sy)
+        d.click(sx, sy)
+        return jsonify({"ok": True, "snapped": snapped, "x": sx, "y": sy,
+                        "label": label})
+    except Exception as e:
+        _screen_invalidate(serial)
+        return jsonify({"ok": False, "error": f"点击失败: {e}"}), 503
+
+
+@bp.route("/api/screen/tap_text", methods=["POST"])
+@perm_required(PERM_DEVICES)
+def api_screen_tap_text():
+    """按屏幕文字点击：{serial, text}——找到显示该文字的位置并点中心（子串匹配）。
+
+    两步：① UI 树 textContains/descriptionContains 命中 → 点元素中心（原生控件）；
+    ② 未命中 → 截图 OCR 找文字中心（WebView/图片/画布渲染的文字）。
+    返回 {ok, found, method: ui|ocr, matched, x, y}；found=false 表示屏幕确实
+    没有该文字（业务结果非设备错误）；OCR 不可用且 UI 未命中时也返回 found=false。
+    """
+    data = request.json or {}
+    serial = (data.get("serial") or "").strip()
+    text = (data.get("text") or "").strip()
+    if not serial or not text:
+        return jsonify({"ok": False, "error": "缺少 serial/text"}), 400
+    if len(text) > 100:
+        return jsonify({"ok": False, "error": "文字过长（≤100 字符）"}), 400
+    try:
+        d = _screen_get_device(serial)
+        # ① UI 树：text / content-desc 子串匹配（原生控件最快最准）
+        for kw in ({"textContains": text}, {"descriptionContains": text}):
+            try:
+                el = d(**kw)
+                if el.exists(timeout=1.5):
+                    # u2 版本差异：3.x 部分版本 bounds 是方法（el.bounds()）
+                    b = el.bounds() if callable(el.bounds) else el.bounds
+                    el.click()
+                    return jsonify({"ok": True, "found": True, "method": "ui",
+                                    "matched": text,
+                                    "x": (b[0] + b[2]) // 2, "y": (b[1] + b[3]) // 2})
+            except Exception:
+                continue
+        # ② OCR 兜底：截图找文字中心（UI 树没有的渲染文字）
+        img = d.screenshot()
+        if img is not None:
+            from core.ocr import find_on_screen
+            found, center, matched = find_on_screen(img, text)
+            if found:
+                d.click(*center)
+                return jsonify({"ok": True, "found": True, "method": "ocr",
+                                "matched": matched,
+                                "x": center[0], "y": center[1]})
+        return jsonify({"ok": True, "found": False, "method": "",
+                        "matched": "", "x": 0, "y": 0})
+    except Exception as e:
+        _screen_invalidate(serial)
+        return jsonify({"ok": False, "error": f"文字点击失败: {e}"}), 503
+
+@bp.route("/api/screen/swipe", methods=["POST"])
+@perm_required(PERM_DEVICES)
+def api_screen_swipe():
+    """滑动：{serial, x1, y1, x2, y2, duration?}（设备原生分辨率坐标）。"""
+    data = request.json or {}
+    serial = data.get("serial", "")
+    x1, y1, x2, y2 = (data.get(k) for k in ("x1", "y1", "x2", "y2"))
+    if not serial or None in (x1, y1, x2, y2):
+        return jsonify({"ok": False, "error": "缺少 serial/x1/y1/x2/y2"}), 400
+    try:
+        _screen_get_device(serial).swipe(int(x1), int(y1), int(x2), int(y2),
+                                         duration=float(data.get("duration", 0.2)))
+        return jsonify({"ok": True})
+    except Exception as e:
+        _screen_invalidate(serial)
+        return jsonify({"ok": False, "error": f"滑动失败: {e}"}), 503
+
+
+_SCREEN_KEYS = {"back", "home", "recent", "menu", "power", "volume_up",
+                "volume_down", "enter", "delete", "search", "camera"}
+
+@bp.route("/api/screen/key", methods=["POST"])
+@perm_required(PERM_DEVICES)
+def api_screen_key():
+    """按键：{serial, key}（back/home/recent/menu/power 等，见 _SCREEN_KEYS）。"""
+    data = request.json or {}
+    serial, key = data.get("serial", ""), (data.get("key") or "").strip().lower()
+    if not serial or key not in _SCREEN_KEYS:
+        return jsonify({"ok": False, "error": "缺少 serial 或不支持的按键"}), 400
+    try:
+        _screen_get_device(serial).press(key)
+        return jsonify({"ok": True})
+    except Exception as e:
+        _screen_invalidate(serial)
+        return jsonify({"ok": False, "error": f"按键失败: {e}"}), 503
+
+@bp.route("/api/screen/text", methods=["POST"])
+@perm_required(PERM_DEVICES)
+def api_screen_text():
+    """输入文字：{serial, text}（需焦点在输入框，u2 send_keys）。"""
+    data = request.json or {}
+    serial, text = data.get("serial", ""), (data.get("text") or "").strip()
+    if not serial or not text:
+        return jsonify({"ok": False, "error": "缺少 serial/text"}), 400
+    try:
+        _screen_get_device(serial).send_keys(text)
+        return jsonify({"ok": True})
+    except Exception as e:
+        return jsonify({"ok": False, "error": f"输入失败: {e}"}), 503
+
+
+@bp.route("/api/screen/size")
+@perm_required(PERM_DEVICES)
+def api_screen_size():
+    """屏幕原生分辨率（只读，供 MCP 坐标换算：截图是缩放图，操作需原生坐标）。
+
+    返回 {ok, width, height}（如 1080x2400）；离线/不可达 → 503。
+    """
+    serial = request.args.get("serial", "")
+    if not serial:
+        return jsonify({"ok": False, "error": "缺少 serial"}), 400
+    try:
+        d = _screen_get_device(serial)
+        w, h = d.window_size()
+        return jsonify({"ok": True, "width": w, "height": h})
+    except Exception as e:
+        _screen_invalidate(serial)
+        return jsonify({"ok": False, "error": f"获取分辨率失败: {e}"}), 503
+
+
+# ================== API：应用管理（APK 上传/安装）==================
+
+def _current_focus_pkg(serial):
+    """取设备当前前台包名（dumpsys window 解析，失败返回空串）。"""
+    try:
+        r = subprocess.run([ADB_PATH, "-s", serial, "shell", "dumpsys", "window"],
+                           capture_output=True, timeout=20)
+        out = (r.stdout or b"").decode("utf-8", errors="replace")
+        m = re.search(r"mCurrentFocus=.*?([\w.]+)/", out)
+        return m.group(1) if m else ""
+    except Exception:
+        return ""
+
+_screen_u2_cache = {}  # serial -> (ts, device)：大屏高频触控复用连接（60s TTL）
+
+
+def _screen_get_device(serial):
+    """远程看屏用的 u2 连接（60s 缓存复用，避免每次 tap/swipe 都重建连接）。
+
+    大屏高频操作（点击/滑动/按键）每次 u2.connect 有 1-3s 握手开销（atx-agent
+    探测），体验卡顿。缓存 60s 内复用；连接失败（设备离线/重启）时清缓存重建，
+    由调用方把异常转 503。
+    """
+    import time
+    import uiautomator2 as u2
+    now = time.time()
+    cached = _screen_u2_cache.get(serial)
+    if cached and now - cached[0] < 60:
+        return cached[1]
+    d = u2.connect(serial)
+    _screen_u2_cache[serial] = (now, d)
+    if len(_screen_u2_cache) > 30:  # 惰性清理过期项
+        for k in list(_screen_u2_cache):
+            if now - _screen_u2_cache[k][0] >= 60:
+                del _screen_u2_cache[k]
+    return d
+
+
+def _screen_invalidate(serial):
+    """u2 调用失败时清掉缓存（设备离线/atx-agent 重启），下次请求重新连接。"""
+    _screen_u2_cache.pop(serial, None)
+

web/tailscale_api.py

@@ -0,0 +1,98 @@
+"""Tailscale 管理 API（仅管理员）。"""
+import re
+
+from flask import Blueprint, jsonify, request
+
+from core import tailscale_client
+from core.tailscale_client import TailscaleError
+from core.logger import get_logger
+
+_log = get_logger("web")
+from web.auth import admin_required
+
+bp = Blueprint("tailscale", __name__)
+
+@bp.route("/api/tailscale/status")
+@admin_required
+def api_tailscale_status():
+    """Tailscale 管理配置状态（API key / tailnet 是否已配置）。"""
+    c = tailscale_client.tailscale
+    return jsonify({"ok": True, "configured": c.is_configured(),
+                    "hint": c.config_hint() if not c.is_configured() else ""})
+
+@bp.route("/api/tailscale/devices")
+@admin_required
+def api_tailscale_devices():
+    """列出 tailnet 全部设备。"""
+    try:
+        return jsonify({"ok": True, "devices": tailscale_client.tailscale.list_devices()})
+    except TailscaleError as e:
+        return jsonify({"ok": False, "error": str(e)}), 502
+
+@bp.route("/api/tailscale/devices/<device_id>", methods=["POST"])
+@admin_required
+def api_tailscale_device_update(device_id):
+    """更新设备：按传入字段分发到专属端点（改名 /name、授权 /authorized、密钥 /key）。"""
+    data = request.json or {}
+    c = tailscale_client.tailscale
+    try:
+        if "name" in data:
+            c.set_device_name(device_id, data.get("name"))
+        if "authorized" in data:
+            c.set_device_authorized(device_id, data.get("authorized"))
+        if "key_expiry_disabled" in data:
+            c.set_device_key_expiry(device_id, data.get("key_expiry_disabled"))
+        _log.info(f"Tailscale 设备更新 {device_id}: {data}")
+        return jsonify({"ok": True, "msg": "设备已更新"})
+    except TailscaleError as e:
+        return jsonify({"ok": False, "error": str(e)}), 502
+
+@bp.route("/api/tailscale/devices/<device_id>/ip", methods=["POST"])
+@admin_required
+def api_tailscale_device_ip(device_id):
+    """设置设备 IPv4 地址（未公开端点，实测可用）。
+
+    ⚠ 改 IP 会断开设备当前 tailscale 会话，且平台设备池 serial 随之变化，
+    改完需同步更新 STF 设备池（分组/任务目标里的旧 IP 会失效）。
+    """
+    data = request.json or {}
+    ipv4 = (data.get("ipv4") or "").strip()
+    if not ipv4:
+        return jsonify({"ok": False, "error": "缺少 ipv4"}), 400
+    try:
+        tailscale_client.tailscale.set_device_ip(device_id, ipv4)
+        _log.info(f"Tailscale 设备 {device_id} IP 已设置为 {ipv4}")
+        return jsonify({"ok": True, "msg": f"设备 IP 已设置为 {ipv4}"})
+    except TailscaleError as e:
+        return jsonify({"ok": False, "error": str(e)}), 502
+
+@bp.route("/api/tailscale/devices/<device_id>", methods=["DELETE"])
+@admin_required
+def api_tailscale_device_delete(device_id):
+    """从 tailnet 移除设备。"""
+    try:
+        tailscale_client.tailscale.delete_device(device_id)
+        _log.info(f"Tailscale 设备已移除: {device_id}")
+        return jsonify({"ok": True, "msg": "设备已从 tailnet 移除"})
+    except TailscaleError as e:
+        return jsonify({"ok": False, "error": str(e)}), 502
+
+@bp.route("/api/tailscale/authkey", methods=["POST"])
+@admin_required
+def api_tailscale_authkey():
+    """生成设备接入 auth key（key 只显示一次）。"""
+    data = request.json or {}
+    try:
+        # Tailscale 要求 description 仅 ASCII（中文会 400）
+        desc = re.sub(r"[^\x20-\x7e]", "", (data.get("description") or "").strip())
+        key = tailscale_client.tailscale.create_auth_key(
+            description=desc or "auto_control",
+            reusable=bool(data.get("reusable", False)),
+            ephemeral=bool(data.get("ephemeral", False)),
+            preauthorized=data.get("preauthorized", True),
+            expiry_seconds=int(data.get("expiry_seconds", 3600)))
+        _log.info(f"Tailscale auth key 已生成: {key['id']}")
+        return jsonify({"ok": True, "key": key["key"], "id": key["id"],
+                        "expires": key["expires"]})
+    except TailscaleError as e:
+        return jsonify({"ok": False, "error": str(e)}), 502

web/tasks_api.py

@@ -0,0 +1,339 @@
+"""任务域 API：任务计划/分组/自定义动作/元素抓取/步骤测试。"""
+import re
+import time
+import uuid
+import threading
+from datetime import datetime
+from concurrent.futures import ThreadPoolExecutor, as_completed, TimeoutError as FuturesTimeout
+
+from flask import (Blueprint, jsonify, request, Response)
+from flask_login import login_required
+
+from core import device_pool, uiauto_helper
+from core.adb_helper import adb_connect_light
+from core.models import db, DeviceGroup, TaskJob, CustomAction
+from core.logger import get_logger
+
+_log = get_logger("web")
+from web import context
+from web.auth import perm_required, PERM_DEVICES, PERM_TASKS
+from tasks import list_task_types, get_task_class
+from web.common import _merged_device_list
+
+bp = Blueprint("tasks", __name__)
+
+@bp.route("/api/task_types")
+@login_required
+def api_task_types():
+    return jsonify({"ok": True, "task_types": list_task_types()})
+
+@bp.route("/api/actions")
+@login_required
+def api_actions():
+    """返回指定任务类型支持的专属操作。"""
+    task_type = request.args.get("task_type", "")
+    task_cls = get_task_class(task_type)
+    if not task_cls:
+        return jsonify({"ok": False, "error": "未知任务类型", "actions": []})
+    actions = task_cls.list_action_types()
+    return jsonify({"ok": True, "actions": actions})
+
+@bp.route("/api/devices")
+@login_required
+def api_devices():
+    """返回所有在线设备 serial（供分组表单勾选用）。"""
+    try:
+        return jsonify({"ok": True, "devices": context.mgr.list_all_serials()})
+    except Exception as e:
+        return jsonify({"ok": False, "error": str(e)}), 500
+
+
+# ================== API：任务计划 CRUD ==================
+def _job_next_run(job):
+    """任务下次执行时间，格式化为 "YYYY-MM-DD HH:MM"（Flask 序列化 aware datetime 会变 GMT 格式）。"""
+    nr = context.mgr.next_run_of(job)
+    return nr.strftime("%Y-%m-%d %H:%M") if nr else None
+
+@bp.route("/api/jobs")
+@login_required
+def api_jobs_list():
+    jobs = []
+    for j in context.mgr.jobs.values():
+        d = j.to_dict()
+        d["next_run"] = _job_next_run(j)
+        jobs.append(d)
+    return jsonify({"ok": True, "jobs": jobs,
+                    "task_types": list_task_types()})
+
+@bp.route("/api/jobs", methods=["POST"])
+@perm_required(PERM_TASKS)
+def api_jobs_create():
+    data = request.json or {}
+    name = (data.get("name") or "").strip()
+    if not name:
+        return jsonify({"ok": False, "error": "任务名不能为空"}), 400
+    task_type = data.get("task_type", "douyin_nurture")
+    if not get_task_class(task_type):
+        return jsonify({"ok": False, "error": f"未知任务类型: {task_type}"}), 400
+    job = context.mgr.add_job(
+        name=name, task_type=task_type,
+        target=data.get("target", {"mode": "all"}),
+        params=data.get("params", {}),
+        schedule=data.get("schedule", {"mode": "once"}),
+        retry=data.get("retry", {"max_attempts": 1, "delay": 60}),
+        enabled=data.get("enabled", True))
+    d = job.to_dict()
+    d["next_run"] = _job_next_run(job)
+    return jsonify({"ok": True, "msg": "任务已创建", "job": d})
+
+@bp.route("/api/jobs/<job_id>", methods=["PUT"])
+@perm_required(PERM_TASKS)
+def api_jobs_update(job_id):
+    job = context.mgr.jobs.get(job_id)
+    if not job:
+        return jsonify({"ok": False, "error": "任务不存在"}), 404
+    data = request.json or {}
+    fields = {}
+    for k in ("name", "task_type", "target", "params", "schedule", "retry", "enabled"):
+        if k in data:
+            fields[k] = data[k]
+    if "task_type" in fields and not get_task_class(fields["task_type"]):
+        return jsonify({"ok": False, "error": f"未知任务类型: {fields['task_type']}"}), 400
+    context.mgr.update_job(job_id, **fields)
+    d = job.to_dict()
+    d["next_run"] = _job_next_run(job)
+    return jsonify({"ok": True, "msg": "任务已更新", "job": d})
+
+@bp.route("/api/jobs/<job_id>", methods=["DELETE"])
+@perm_required(PERM_TASKS)
+def api_jobs_delete(job_id):
+    if context.mgr.delete_job(job_id):
+        return jsonify({"ok": True, "msg": "任务已删除"})
+    return jsonify({"ok": False, "error": "任务不存在"}), 404
+
+@bp.route("/api/jobs/<job_id>/run", methods=["POST"])
+@perm_required(PERM_TASKS)
+def api_jobs_run(job_id):
+    return jsonify(context.mgr.run_job_now(job_id))
+
+@bp.route("/api/jobs/<job_id>/toggle", methods=["POST"])
+@perm_required(PERM_TASKS)
+def api_jobs_toggle(job_id):
+    enabled = (request.json or {}).get("enabled", True)
+    job = context.mgr.toggle_job(job_id, enabled)
+    if not job:
+        return jsonify({"ok": False, "error": "任务不存在"}), 404
+    return jsonify({"ok": True, "msg": f"任务已{'启用' if enabled else '停用'}"})
+
+
+# ================== API：设备分组 CRUD ==================
+
+@bp.route("/api/groups")
+@login_required
+def api_groups_list():
+    return jsonify({"ok": True, "groups": [g.to_dict() for g in context.mgr.groups.values()]})
+
+@bp.route("/api/groups", methods=["POST"])
+@perm_required(PERM_TASKS)
+def api_groups_create():
+    data = request.json or {}
+    name = (data.get("name") or "").strip()
+    if not name:
+        return jsonify({"ok": False, "error": "分组名不能为空"}), 400
+    if name in context.mgr.groups:
+        return jsonify({"ok": False, "error": "分组名已存在"}), 400
+    context.mgr.add_group(name, data.get("serials", []), data.get("description", ""))
+    return jsonify({"ok": True, "msg": "分组已创建"})
+
+@bp.route("/api/groups/<name>", methods=["PUT"])
+@perm_required(PERM_TASKS)
+def api_groups_update(name):
+    if name not in context.mgr.groups:
+        return jsonify({"ok": False, "error": "分组不存在"}), 404
+    data = request.json or {}
+    context.mgr.update_group(name,
+                     serials=data.get("serials"),
+                     description=data.get("description"))
+    return jsonify({"ok": True, "msg": "分组已更新"})
+
+@bp.route("/api/groups/<name>", methods=["DELETE"])
+@perm_required(PERM_TASKS)
+def api_groups_delete(name):
+    if context.mgr.delete_group(name):
+        return jsonify({"ok": True, "msg": "分组已删除"})
+    return jsonify({"ok": False, "error": "分组不存在"}), 404
+
+
+# ================== API：用户管理 CRUD ==================
+
+@bp.route("/api/custom_actions")
+@login_required
+def api_custom_actions_list():
+    rows = CustomAction.query.order_by(CustomAction.created_at.desc()).all()
+    return jsonify({"ok": True, "actions": [r.to_dict() for r in rows]})
+
+@bp.route("/api/custom_actions", methods=["POST"])
+@perm_required(PERM_TASKS)
+def api_custom_actions_create():
+    data = request.json or {}
+    name = (data.get("name") or "").strip()
+    if not name:
+        return jsonify({"ok": False, "error": "动作名不能为空"}), 400
+    steps = data.get("steps", [])
+    if not steps:
+        return jsonify({"ok": False, "error": "至少需要1个步骤"}), 400
+    row = CustomAction(id=uuid.uuid4().hex[:8], name=name,
+                       icon=data.get("icon") or "📦",
+                       created_at=datetime.now().strftime("%Y-%m-%d %H:%M"))
+    row.set_steps(steps)
+    db.session.add(row)
+    db.session.commit()
+    return jsonify({"ok": True, "msg": "动作已保存", "action": row.to_dict()})
+
+@bp.route("/api/custom_actions/<action_id>", methods=["PUT"])
+@perm_required(PERM_TASKS)
+def api_custom_actions_update(action_id):
+    row = CustomAction.query.get(action_id)
+    if not row:
+        return jsonify({"ok": False, "error": "动作不存在"}), 404
+    data = request.json or {}
+    if "name" in data:
+        name = (data["name"] or "").strip()
+        if not name:
+            return jsonify({"ok": False, "error": "动作名不能为空"}), 400
+        row.name = name
+    if "icon" in data:
+        row.icon = data["icon"] or "📦"
+    if "steps" in data:
+        if not data["steps"]:
+            return jsonify({"ok": False, "error": "至少需要1个步骤"}), 400
+        row.set_steps(data["steps"])
+    db.session.commit()
+    return jsonify({"ok": True, "msg": "已更新", "action": row.to_dict()})
+
+@bp.route("/api/custom_actions/<action_id>", methods=["DELETE"])
+@perm_required(PERM_TASKS)
+def api_custom_actions_delete(action_id):
+    row = CustomAction.query.get(action_id)
+    if not row:
+        return jsonify({"ok": False, "error": "动作不存在"}), 404
+    db.session.delete(row)
+    db.session.commit()
+    return jsonify({"ok": True, "msg": "已删除"})
+
+@bp.route("/api/uiauto/elements")
+@perm_required(PERM_DEVICES)
+def api_uiauto_elements():
+    """获取设备当前 UI 元素树（供步骤编辑器"抓取元素"用）。
+
+    依赖本地运行的 uiautodev 服务（端口 20242）。
+    ?serial=xxx  设备 serial
+    返回：
+      200 — {ok:true, elements:[...]}
+      503 — {ok:false, error:"..."}（uiauto2 未启动）
+    """
+    serial = request.args.get("serial", "")
+    if not serial:
+        return jsonify({"ok": False, "error": "缺少 serial"}), 400
+    ok, data = uiauto_helper.get_elements(serial)
+    if ok:
+        return jsonify({"ok": True, "elements": data})
+    return jsonify({"ok": False, "error": data}), 503
+
+@bp.route("/api/uiauto/status")
+@login_required
+def api_uiauto_status():
+    """探测 uiauto2 本地服务是否运行（前端按钮禁启用）。"""
+    return jsonify({"ok": True, "running": uiauto_helper.is_running()})
+
+@bp.route("/api/steps/test", methods=["POST"])
+@perm_required(PERM_DEVICES)
+def api_steps_test():
+    """测试单个步骤：在指定设备上试执行，验证选择器是否命中（步骤编辑器"测试此步骤"）。
+
+    请求: {"serial": "100.100.10.11:5555", "step": {"type": "click", "params": {...}}}
+    只读连接（adb connect + u2），与运行中任务互不干扰。
+    返回 result: "命中" / "未找到" / "已执行"。
+    """
+    data = request.json or {}
+    serial = (data.get("serial") or "").strip()
+    step = data.get("step") or {}
+    if not serial:
+        return jsonify({"ok": False, "error": "缺少 serial"}), 400
+    if not step.get("type"):
+        return jsonify({"ok": False, "error": "缺少步骤类型"}), 400
+    from tasks.generic.task import test_step
+    ok, msg, result = test_step(serial, step)
+    res_txt = {True: "命中", False: "未找到"}.get(result, "已执行")
+    _log.info(f"测试步骤 {step.get('type')} @ {serial}: {res_txt} ({msg})")
+    return jsonify({"ok": ok, "msg": msg, "result": res_txt})
+
+@bp.route("/api/uiauto/devices")
+@perm_required(PERM_DEVICES)
+def api_uiauto_devices():
+    """获取可选设备列表（抓取元素用）。
+
+    uiautodev 只认识本地 adb 已连接的设备；设备池里在线但未本地连接的设备
+    在这里补全，并先做一次轻量 adb connect（单次尝试，绝不 kill-server），
+    让它们可被 uiautodev 抓取。
+    """
+    ok, data = uiauto_helper.list_devices()
+    if not ok:
+        return jsonify({"ok": False, "error": data}), 503
+    seen = {d.get("serial") for d in data}
+    try:
+        online = set(device_pool.list_online())
+        pool = [s for s in device_pool.list_configured() if s in online]
+    except Exception:
+        pool = []
+    added = 0
+    for serial in pool:
+        if not serial or serial in seen:
+            continue
+        # 轻量连接（单次尝试，不重试不 kill-server）；连不上也照样列出，
+        # 前端抓取时会报明确错误，不影响其他设备的连接
+        adb_connect_light(serial)
+        data.append({
+            "serial": serial,
+            "model": "",
+            "product": "",
+            "name": serial,
+            "status": "device",
+            "enabled": True,
+        })
+        seen.add(serial)
+        added += 1
+    if added:
+        _log.info(f"抓取元素设备列表补全 {added} 台在线设备: {list(seen)}")
+    return jsonify({"ok": True, "devices": data})
+
+@bp.route("/api/uiauto/screenshot")
+@perm_required(PERM_DEVICES)
+def api_uiauto_screenshot():
+    """通过 uiauto2 获取设备截图（供抓取元素时显示设备画面）。
+
+    ?serial=xxx  设备 serial
+    直接返回 image/jpeg，前端用 <img> 加载。
+    """
+    serial = request.args.get("serial", "")
+    if not serial:
+        return jsonify({"ok": False, "error": "缺少 serial"}), 400
+    ok, data = uiauto_helper.get_screenshot(serial)
+    if ok:
+        return Response(data, mimetype="image/jpeg",
+                        headers={"Cache-Control": "no-store"})
+    return jsonify({"ok": False, "error": data}), 503
+
+
+# ================== API：远程看屏（阶段 2） ==================
+# MJPEG 实时画面流 + u2 触控注入。数据源 u2（atx-agent minicap 截图，单帧 ~200ms），
+# 零新依赖（原计划 ws-scrcpy 不在 npm 分发，GitHub 下载在国内不可靠，改自建）。
+# 坐标约定：前端以 <img> 显示尺寸归一化后映射到设备原生分辨率（naturalWidth/Height）。
+_SCREEN_JPEG_QUALITY = 65
+_SCREEN_FRAME_GAP = 0.05  # 帧间最小间隔（秒），防止空转烧 CPU
+
+def _job_next_run(job):
+    """任务下次执行时间，格式化为 "YYYY-MM-DD HH:MM"（Flask 序列化 aware datetime 会变 GMT 格式）。"""
+    nr = context.mgr.next_run_of(job)
+    return nr.strftime("%Y-%m-%d %H:%M") if nr else None
+

web/tools_api.py

@@ -0,0 +1,249 @@
+"""工具域 API：adb 终端/剪贴板注入/应用版本。"""
+import re
+import subprocess
+import shlex
+from concurrent.futures import ThreadPoolExecutor, as_completed
+
+from flask import Blueprint, jsonify, request
+
+from core import device_pool
+from core.adb_helper import adb_connect, adb_connect_light, _ADB_LOCK, _adb
+from config import ADB_PATH
+from core.logger import get_logger
+from web import context
+from web.auth import admin_required, perm_required
+from web.common import _merged_device_list
+
+_log = get_logger("web")
+bp = Blueprint("tools", __name__)
+
+# adb 终端安全红线：绝不 kill-server / 绝不 disconnect IP:5555——
+# 共享 adb transport，断开会让全部设备连接重建（历史与 STF provider 共用）。
+_ADB_BLOCKED_PATTERNS = ("kill-server", "disconnect")
+
+@bp.route("/api/adb/devices")
+@admin_required
+def api_adb_devices():
+    """维护终端设备列表（仅管理员）：本地 adb 已连接 + 设备池（SQLite）。
+
+    状态：device/offline=本机 adb 实际状态；pool=设备池已配置但本机未连接。
+    供终端设备选择器使用——选中后自动附加 `-s <serial>`，
+    离线/未连接的设备也可选，配合"重连设备"按钮恢复。
+    """
+    return jsonify({"ok": True, "devices": _merged_device_list()})
+
+@bp.route("/api/adb/cmd", methods=["POST"])
+@admin_required
+def api_adb_cmd():
+    """维护终端：执行 adb 命令（仅管理员）。
+
+    请求: {"cmd": "adb -s 100.100.10.11:5555 shell ls /sdcard"}
+    用平台 adb 二进制执行（config.ADB_PATH），带 20s 超时。
+    """
+    data = request.json or {}
+    cmd = (data.get("cmd") or "").strip()
+    if not cmd:
+        return jsonify({"ok": False, "error": "命令不能为空"}), 400
+    if _blocked_adb_cmd(cmd):
+        return jsonify({"ok": False,
+                        "error": "禁止执行 kill-server / disconnect（会中断 STF 设备监控，影响所有任务）"}), 400
+    tokens = shlex.split(cmd)
+    if tokens and tokens[0] == "adb":
+        tokens = tokens[1:]
+    if not tokens:
+        return jsonify({"ok": False, "error": "命令不能为空"}), 400
+    try:
+        # 与 worker 的 adb 调用共用锁，避免并发操作同一 adb server
+        with _ADB_LOCK:
+            r = subprocess.run([ADB_PATH, *tokens], capture_output=True, timeout=20)
+        out = (r.stdout or b"").decode("utf-8", errors="replace")
+        err = (r.stderr or b"").decode("utf-8", errors="replace")
+        _log.info(f"维护终端执行 adb {' '.join(tokens)} -> exit {r.returncode}")
+        return jsonify({"ok": True, "stdout": out, "stderr": err, "code": r.returncode})
+    except subprocess.TimeoutExpired:
+        return jsonify({"ok": False, "error": "命令执行超时（20s）"}), 408
+    except Exception as e:
+        _log.warning(f"维护终端 adb 执行异常: {e}")
+        return jsonify({"ok": False, "error": f"执行失败: {e}"}), 500
+
+@bp.route("/api/tools/clipboard/set", methods=["POST"])
+@admin_required
+def api_tools_clipboard_set():
+    """工具-剪贴板注入：把指定文字写入一台或多台设备的剪贴板。
+
+    请求: {"serials": ["100.100.10.11:5555", ...], "text": "要注入的文字"}
+    设备来源与维护终端一致：本地 adb 已连接设备（含 USB）+ 设备池。
+    实现：u2 jsonrpc.setClipboard（实测 cmd clipboard 在 MIUI 上不存在）。
+    """
+    data = request.json or {}
+    serials = data.get("serials") or []
+    text = (data.get("text") or "").strip()
+    if not isinstance(serials, list) or not serials:
+        return jsonify({"ok": False, "error": "未选择设备"}), 400
+    if not text:
+        return jsonify({"ok": False, "error": "注入内容不能为空"}), 400
+    results = {}
+    for serial in serials:
+        ok, msg = _set_device_clipboard(serial, text)
+        results[serial] = {"ok": ok, "msg": msg}
+    ok_count = sum(1 for v in results.values() if v["ok"])
+    fail_count = len(results) - ok_count
+    return jsonify({"ok": True, "results": results,
+                    "ok_count": ok_count, "fail_count": fail_count,
+                    "error": None if ok_count == len(results) else f"{fail_count} 台设备注入失败"})
+
+
+def _set_device_clipboard(serial, text):
+    """向单台设备注入剪贴板文字（ClipInject 通道，见 core.clipboard_helper）。"""
+    from core.clipboard_helper import inject_clipboard
+    return inject_clipboard(serial, text)
+
+
+def _app_ver_on_device(serial, pkg):
+    """单设备包版本查询：pm path 检查安装 → dumpsys 取 versionName/versionCode。
+
+    IP:port 设备先轻量 adb connect（单次尝试，绝不 disconnect，红线）。
+    查询是只读 shell 命令，无需 adb server 锁（锁只保护 connect/kill-server 类操作）。
+    """
+    if ":" in serial:
+        try:
+            adb_connect_light(serial)
+        except Exception as e:
+            return {"installed": False, "error": f"adb 连接失败: {e}"}
+    try:
+        r = subprocess.run([ADB_PATH, "-s", serial, "shell", "pm", "path", pkg],
+                           capture_output=True, timeout=15)
+        if b"package:" not in (r.stdout or b""):
+            return {"installed": False, "version_name": "", "version_code": ""}
+        r2 = subprocess.run([ADB_PATH, "-s", serial, "shell", "dumpsys", "package", pkg],
+                            capture_output=True, timeout=20)
+        out2 = (r2.stdout or b"").decode("utf-8", errors="replace")
+        vm = re.search(r"versionName=(\S+)", out2)
+        vc = re.search(r"versionCode=(\d+)", out2)
+        return {"installed": True,
+                "version_name": vm.group(1) if vm else "",
+                "version_code": vc.group(1) if vc else ""}
+    except subprocess.TimeoutExpired:
+        return {"installed": False, "error": "查询超时"}
+    except Exception as e:
+        return {"installed": False, "error": str(e)}
+
+@bp.route("/api/tools/appver", methods=["POST"])
+@admin_required
+def api_tools_appver():
+    """工具-应用版本管理：查询所有设备上指定包名的安装情况与版本号。
+
+    请求: {"pkg": "com.ss.android.ugc.aweme"}
+    设备来源：本地 adb（含 USB）+ 设备池，并发查询（最多 10 台同时）。
+    """
+    pkg = (request.json or {}).get("pkg", "").strip()
+    if not re.match(r"^[A-Za-z0-9_.]+$", pkg or ""):
+        return jsonify({"ok": False, "error": "包名格式不正确（仅字母/数字/._）"}), 400
+    # 只查在线设备：池内离线条目（如陈旧记录）不连，避免 connect 重试拖慢查询
+    try:
+        online = set(device_pool.list_online())
+        devices = [d for d in _merged_device_list() if d["serial"] in online]
+    except Exception:
+        devices = []
+    if not devices:
+        return jsonify({"ok": False, "error": "无在线设备"}), 404
+    results = {}
+    with ThreadPoolExecutor(max_workers=min(10, len(devices))) as pool:
+        futures = {pool.submit(_app_ver_on_device, d["serial"], pkg): d for d in devices}
+        for fut in as_completed(futures, timeout=90):
+            d = futures[fut]
+            try:
+                results[d["serial"]] = fut.result()
+            except Exception as e:
+                results[d["serial"]] = {"installed": False, "error": str(e)}
+    fail = sum(1 for v in results.values() if v.get("error"))
+    return jsonify({"ok": True, "results": results, "fail": fail,
+                    "total": len(results)})
+
+def _blocked_adb_cmd(cmd):
+    """命中红线的 adb 命令（kill-server / disconnect）直接拒绝。"""
+    low = cmd.lower()
+    return any(p in low for p in _ADB_BLOCKED_PATTERNS)
+
+def _set_device_clipboard(serial, text):
+    """向单台设备注入剪贴板文字（ClipInject APK：透明 Activity 聚焦后写入）。
+
+    Android 10+ 禁止后台（atx-agent/shell）写剪贴板，u2.set_clipboard 在
+    Android 12/13 上调用"成功"但内容被系统静默丢弃。ClipInject
+    （com.example.clipinject）通过 am start 启动透明 Activity，窗口聚焦后
+    setPrimaryClip，shell 启动 Activity 不受后台启动限制（广播方式在 MIUI
+    会被 Background activity start 拦截，必须用 am start）。
+
+    - IP:port 设备：先 adb connect（已连接自动跳过；绝不 disconnect，红线）
+    - 设备未装 ClipInject：am start 返回 unable to resolve Intent，明确报错
+    - 注入后 u2 读回比对验证（后台读剪贴板实测可用），不一致也明确报错
+    """
+    import base64
+    import time
+    import uiautomator2 as u2
+    if ":" in serial:
+        try:
+            adb_connect(serial)
+        except Exception as e:
+            return False, f"adb 连接失败: {e}"
+    b64 = base64.b64encode(text.encode("utf-8")).decode()
+    # 1. am start 透明 Activity 写剪贴板（shell 身份启动，不受后台启动限制）
+    try:
+        r = subprocess.run(
+            [ADB_PATH, "-s", serial, "shell", "am", "start",
+             "-n", "com.example.clipinject/.ClipActivity",
+             "--es", "text_b64", b64],
+            capture_output=True, timeout=30)
+        out = ((r.stdout or b"") + (r.stderr or b"")).decode(errors="replace")
+        if "does not exist" in out or "unable to resolve Intent" in out:
+            return False, ("设备未安装 ClipInject（com.example.clipinject），"
+                           f"请先安装: {out.strip()[:100]}")
+        if "Error" in out or ("Starting" not in out and r.returncode != 0):
+            return False, f"am start 失败: {out.strip()[:120]}"
+    except subprocess.TimeoutExpired:
+        return False, "am start 超时（adb 无响应）"
+    except Exception as e:
+        return False, f"{type(e).__name__}: {str(e)[:120]}"
+    # 2. 读回验证（等透明 Activity 完成写入；u2 读剪贴板在 Android 12 实测可用）
+    time.sleep(0.5)
+    try:
+        with ThreadPoolExecutor(max_workers=1) as pool:
+            d = pool.submit(u2.connect, serial).result(timeout=30)
+        with ThreadPoolExecutor(max_workers=1) as pool:
+            got = pool.submit(lambda: d.clipboard).result(timeout=15)
+        if got == text:
+            return True, "已注入"
+        return False, f"剪贴板读回不一致（写入可能被拒）: {str(got)[:60]!r}"
+    except Exception as e:
+        # 读回不可用（旧版 u2/连接失败）时按写入成功处理，避免误报，但带上具体原因
+        return True, f"已注入（读回验证不可用: {type(e).__name__}: {str(e)[:80]}）"
+
+def _app_ver_on_device(serial, pkg):
+    """单设备包版本查询：pm path 检查安装 → dumpsys 取 versionName/versionCode。
+
+    IP:port 设备先轻量 adb connect（单次尝试，绝不 disconnect，红线）。
+    查询是只读 shell 命令，无需 adb server 锁（锁只保护 connect/kill-server 类操作）。
+    """
+    if ":" in serial:
+        try:
+            adb_connect_light(serial)
+        except Exception as e:
+            return {"installed": False, "error": f"adb 连接失败: {e}"}
+    try:
+        r = subprocess.run([ADB_PATH, "-s", serial, "shell", "pm", "path", pkg],
+                           capture_output=True, timeout=15)
+        if b"package:" not in (r.stdout or b""):
+            return {"installed": False, "version_name": "", "version_code": ""}
+        r2 = subprocess.run([ADB_PATH, "-s", serial, "shell", "dumpsys", "package", pkg],
+                            capture_output=True, timeout=20)
+        out2 = (r2.stdout or b"").decode("utf-8", errors="replace")
+        vm = re.search(r"versionName=(\S+)", out2)
+        vc = re.search(r"versionCode=(\d+)", out2)
+        return {"installed": True,
+                "version_name": vm.group(1) if vm else "",
+                "version_code": vc.group(1) if vc else ""}
+    except subprocess.TimeoutExpired:
+        return {"installed": False, "error": "查询超时"}
+    except Exception as e:
+        return {"installed": False, "error": str(e)}
+