myagent-ai 1.47.15 → 1.47.17

package/aiskills/browser_stealth.py

@@ -367,6 +367,10 @@ class StealthBrowser:
         self._user_data_dir = ""
         self._xvfb_started_by_us = False  # 是否由本实例独立启动的 Xvfb
         self._vnc_used = False  # 是否使用了 VNC 远程桌面的显示
+        # [v1.47.16] Firefox+VNC 模式：VNC 环境下直接用 Firefox，不走 DrissionPage/Chromium
+        self._firefox_mode = False
+        self._firefox_process: Optional[subprocess.Popen] = None
+        self._firefox_profile_dir = ""
         # [v1.35.0] 浏览器实例级异步锁：防止多个 Agent 并发操作同一个浏览器实例
         # 同一 profile 的浏览器共享 _page，并发操作会导致竞态（导航冲突、点击错位等）
         self._usage_lock = asyncio.Lock()
@@ -540,6 +544,73 @@ class StealthBrowser:
 
     async def start(self) -> SkillResult:
         """启动反检测浏览器"""
+        # [v1.47.16] VNC/Termux 模式下直接使用 Firefox，不走 DrissionPage/Chromium
+        # Chromium 在 proot ARM64 下与 DrissionPage 不兼容，
+        # 所以 VNC 模式下先检测环境，直接走 Firefox 路径，不需要 import DrissionPage
+        _is_vnc_mode = False
+        _is_termux_env = False
+        try:
+            from core.env_detect import is_termux
+            _is_termux_env = is_termux()
+        except ImportError:
+            pass
+        try:
+            from core.env_detect import is_desktop
+            if not is_desktop():
+                _is_vnc_mode = True
+        except ImportError:
+            if not _has_display():
+                _is_vnc_mode = True
+
+        # VNC 模式：跳过所有 Chrome/DrissionPage 逻辑，直接用 Firefox
+        if _is_vnc_mode:
+            logger.info("VNC/非桌面环境: 直接启动 Firefox（跳过 Chromium 检测）")
+            if not self._headless:
+                display = _ensure_display()
+                if display:
+                    self._vnc_used = display.get("vnc", False)
+                    self._xvfb_started_by_us = display.get("xvfb_standalone", False)
+                    if self._vnc_used:
+                        return self._start_firefox_in_vnc()
+                # VNC/Xvfb 不可用
+                if _is_termux_env:
+                    return SkillResult(
+                        success=False,
+                        error=(
+                            "Termux+Ubuntu 环境仅支持通过 VNC 启动浏览器，"
+                            "VNC 启动失败。请先启动 VNC 远程桌面后再使用浏览器功能。"
+                        ),
+                    )
+                # 非 Termux：尝试 Xvfb
+                if display and display.get("xvfb_standalone"):
+                    # 有 Xvfb 但没有 VNC → 用 Xvfb + Chromium（走下面的正常流程）
+                    pass
+                else:
+                    # 没有 Xvfb 也没有 VNC → 降级 headless 或报错
+                    logger.warning("无显示环境且 VNC/Xvfb 均不可用，尝试 Firefox headless 模式")
+                    return self._start_firefox_in_vnc()
+            else:
+                # headless=True 被显式请求
+                if _is_termux_env:
+                    logger.info("Termux+Ubuntu 环境: 忽略 headless 请求，强制使用 VNC 模式")
+                    self._headless = False
+                    display = _ensure_display()
+                    if display:
+                        self._vnc_used = display.get("vnc", False)
+                        self._xvfb_started_by_us = display.get("xvfb_standalone", False)
+                        if self._vnc_used:
+                            return self._start_firefox_in_vnc()
+                    return SkillResult(
+                        success=False,
+                        error=(
+                            "Termux+Ubuntu 环境仅支持通过 VNC 启动浏览器，"
+                            "VNC 启动失败。headless 模式在此环境下不可用。"
+                        ),
+                    )
+                # 非 Termux headless → 仍然尝试 Firefox
+                return self._start_firefox_in_vnc()
+
+        # ── 桌面环境：使用 DrissionPage + Chromium ──
         try:
             from DrissionPage import Chromium, ChromiumOptions
         except ImportError:
@@ -609,88 +680,10 @@ class StealthBrowser:
             else:
                 logger.info("桌面环境，使用系统 Chrome 原生参数")
 
-            # ── 无显示环境处理 ──
-            # 桌面环境 (Windows/macOS/Linux有真实显示器): 直接用系统 Chrome
-            # Termux+Ubuntu: 仅支持 VNC，不降级到 headless
-            # 非 Termux 容器: VNC > Xvfb > headless 降级
-            _is_termux_env = False
-            try:
-                from core.env_detect import is_termux
-                _is_termux_env = is_termux()
-            except ImportError:
-                pass
-
+            # ── 显示环境处理（仅桌面环境到达此代码路径）──
+            # VNC/Termux 模式已在方法开头走 Firefox 分支，这里只处理桌面环境
             if not self._headless:
-                try:
-                    from core.env_detect import is_desktop
-                    if is_desktop():
-                        # 桌面环境: 直接用系统 Chrome
-                        logger.info("桌面环境，直接使用系统浏览器，跳过 VNC/Xvfb")
-                    else:
-                        # 非桌面环境 (容器/Termux): 通过 _ensure_display() 获取显示
-                        display = _ensure_display()
-                        if display:
-                            self._vnc_used = display.get("vnc", False)
-                            self._xvfb_started_by_us = display.get("xvfb_standalone", False)
-                            if self._vnc_used:
-                                logger.info(f"复用 VNC 远程桌面显示 ({display['display']}），可在 VNC 中查看浏览器操作")
-                        else:
-                            # ── Termux+Ubuntu: VNC 失败 → 直接报错，不降级 headless ──
-                            if _is_termux_env:
-                                return SkillResult(
-                                    success=False,
-                                    error=(
-                                        "Termux+Ubuntu 环境仅支持通过 VNC 启动浏览器，"
-                                        "VNC 启动失败。请先启动 VNC 远程桌面，"
-                                        "或通过 Web 管理面板打开 VNC 后再使用浏览器功能。"
-                                    ),
-                                )
-                            # ── 非 Termux 容器: 降级到 headless ──
-                            self._headless = True
-                            logger.warning(
-                                "无显示环境且 VNC/Xvfb 均不可用，自动降级为 headless 模式"
-                            )
-                except ImportError:
-                    # env_detect 不可用时，降级为原有 X11 检测逻辑
-                    if not _has_display():
-                        display = _ensure_display()
-                        if display:
-                            self._vnc_used = display.get("vnc", False)
-                            self._xvfb_started_by_us = display.get("xvfb_standalone", False)
-                        else:
-                            if _is_termux_env:
-                                return SkillResult(
-                                    success=False,
-                                    error=(
-                                        "Termux+Ubuntu 环境仅支持通过 VNC 启动浏览器，"
-                                        "VNC 启动失败。请先启动 VNC 远程桌面后再使用浏览器功能。"
-                                    ),
-                                )
-                            self._headless = True
-                            logger.warning(
-                                "无 DISPLAY 环境且 VNC/Xvfb 均不可用，自动降级为 headless 模式"
-                            )
-            else:
-                # headless=True 被显式请求，但 Termux 环境下仍强制使用 VNC
-                # 因为 headless Chromium 在 Termux 下容易被 OOM Kill
-                if _is_termux_env:
-                    logger.info("Termux+Ubuntu 环境: 忽略 headless 请求，强制使用 VNC 模式")
-                    self._headless = False
-                    display = _ensure_display()
-                    if display:
-                        self._vnc_used = display.get("vnc", False)
-                        self._xvfb_started_by_us = display.get("xvfb_standalone", False)
-                        if self._vnc_used:
-                            logger.info(f"Termux+Ubuntu: 已通过 VNC 获取显示 ({display['display']})")
-                    else:
-                        return SkillResult(
-                            success=False,
-                            error=(
-                                "Termux+Ubuntu 环境仅支持通过 VNC 启动浏览器，"
-                                "VNC 启动失败。headless 模式在此环境下不可用（容易被 OOM Kill）。"
-                                "请先启动 VNC 远程桌面后再使用浏览器功能。"
-                            ),
-                        )
+                logger.info("桌面环境，直接使用系统浏览器，跳过 VNC/Xvfb")
 
             # 无头模式（co.headless() 内部设置 --headless=new）
             if self._headless:
@@ -818,9 +811,179 @@ class StealthBrowser:
                 error=f"启动反检测浏览器失败: {e}",
             )
 
+    def _start_firefox_in_vnc(self) -> SkillResult:
+        """[v1.47.16] VNC 模式下直接启动 Firefox。
+
+        在 VNC/Termux 环境下，Chromium 与 DrissionPage 不兼容
+       （proot ARM64 下报 "browser executable file path cannot be found"），
+        直接用 Firefox 在 VNC 中运行。
+
+        Firefox 模式下:
+          - navigate: 通过 subprocess 打开 URL（Firefox 支持远程打开 URL）
+          - screenshot: 通过 xdotool + import (ImageMagick) 截图
+          - click/fill: 通过 xdotool 发送鼠标/键盘事件
+          - cookie: 读取 Firefox profile 目录中的 cookies.sqlite
+        """
+        self._firefox_mode = True
+        display = os.environ.get("DISPLAY", ":99")
+
+        # 1. 检测 Firefox 路径
+        firefox_path = None
+        for candidate in ("firefox", "myagent-browser"):
+            found = shutil.which(candidate)
+            if found:
+                # 跳过 snap 包装器
+                if self._is_snap_wrapper(found):
+                    logger.info(f"跳过 {candidate} ({found}) — snap 包装器，proot 下不可用")
+                    continue
+                firefox_path = found
+                break
+
+        if not firefox_path:
+            # 搜索常见路径
+            for p in ("/usr/bin/firefox", "/usr/local/bin/firefox",
+                      "/snap/bin/firefox"):
+                if os.path.isfile(p) and os.access(p, os.X_OK):
+                    if self._is_snap_wrapper(p):
+                        continue
+                    firefox_path = p
+                    break
+
+        if not firefox_path:
+            return SkillResult(
+                success=False,
+                error="VNC 模式下未找到 Firefox 浏览器。请安装 Firefox: apt install firefox",
+            )
+
+        logger.info(f"[_start_firefox_in_vnc] 使用 Firefox: {firefox_path}")
+
+        # 2. 准备 Firefox Profile 目录
+        if self._custom_user_data_dir:
+            self._firefox_profile_dir = self._custom_user_data_dir
+        else:
+            from core.browser_profile import get_browser_profile_manager
+            mgr = get_browser_profile_manager()
+            profile = mgr.get_profile(self.profile_name)
+            profile.ensure_dirs()
+            self._firefox_profile_dir = str(profile.profile_dir)
+
+        # 确保目录存在
+        try:
+            os.makedirs(self._firefox_profile_dir, exist_ok=True)
+        except Exception as e:
+            logger.warning(f"创建 Firefox Profile 目录失败: {e}")
+
+        # 3. 检查是否已有 Firefox 运行
+        try:
+            result = subprocess.run(
+                ["pgrep", "-f", "firefox"],
+                capture_output=True, text=True, timeout=5,
+            )
+            if result.returncode == 0 and result.stdout.strip():
+                logger.info(f"检测到已有 Firefox 运行 (PID: {result.stdout.strip().split()[0]})，复用")
+                self._started = True
+                return SkillResult(
+                    success=True,
+                    message=f"Firefox 已在 VNC 中运行 (Profile: {self.profile_name})",
+                    data={"profile": self.profile_name, "mode": "firefox_vnc", "reused": True},
+                )
+        except Exception:
+            pass
+
+        # 4. 启动 Firefox
+        env = {**os.environ, "DISPLAY": display}
+        # proot 兼容环境变量
+        if not env.get("G_SLICE"):
+            env["G_SLICE"] = "always-malloc"
+        if not env.get("GSETTINGS_BACKEND"):
+            env["GSETTINGS_BACKEND"] = "memory"
+        if os.environ.get("DBUS_SESSION_BUS_ADDRESS"):
+            env["DBUS_SESSION_BUS_ADDRESS"] = os.environ["DBUS_SESSION_BUS_ADDRESS"]
+        xdg_runtime = env.get("XDG_RUNTIME_DIR") or f"/run/user/{os.getuid()}"
+        env["XDG_RUNTIME_DIR"] = xdg_runtime
+        try:
+            os.makedirs(xdg_runtime, exist_ok=True)
+            os.chmod(xdg_runtime, 0o700)
+        except Exception:
+            pass
+
+        try:
+            firefox_cmd = [
+                firefox_path,
+                "--profile", self._firefox_profile_dir,
+                "--width", "960",
+                "--height", "540",
+                "--no-remote",
+            ]
+            logger.info(f"[_start_firefox_in_vnc] 启动: {' '.join(firefox_cmd)}")
+            self._firefox_process = subprocess.Popen(
+                firefox_cmd,
+                stdin=subprocess.DEVNULL,
+                stdout=subprocess.DEVNULL,
+                stderr=subprocess.DEVNULL,
+                env=env,
+                preexec_fn=os.setpgrp,
+            )
+            # 等待 Firefox 启动
+            time.sleep(3)
+            if self._firefox_process.poll() is not None:
+                exit_code = self._firefox_process.returncode
+                self._firefox_process = None
+                logger.error(f"Firefox 启动后立即退出 (exit code: {exit_code})")
+                return SkillResult(
+                    success=False,
+                    error=f"Firefox 启动后立即退出 (exit code: {exit_code})",
+                )
+
+            self._started = True
+            logger.info(
+                f"Firefox 已在 VNC 中启动 (PID={self._firefox_process.pid}, "
+                f"profile={self.profile_name})"
+            )
+            return SkillResult(
+                success=True,
+                message=f"Firefox 已在 VNC 中启动 (Profile: {self.profile_name})",
+                data={"profile": self.profile_name, "mode": "firefox_vnc", "pid": self._firefox_process.pid},
+            )
+        except Exception as e:
+            logger.error(f"Firefox 启动失败: {e}")
+            return SkillResult(
+                success=False,
+                error=f"Firefox 启动失败: {e}",
+            )
+
     async def close(self) -> SkillResult:
         """关闭浏览器"""
         self._started = False
+
+        # [v1.47.16] Firefox+VNC 模式
+        if self._firefox_mode:
+            try:
+                if self._firefox_process and self._firefox_process.poll() is None:
+                    self._firefox_process.terminate()
+                    try:
+                        self._firefox_process.wait(timeout=5)
+                    except Exception:
+                        try:
+                            self._firefox_process.kill()
+                        except Exception:
+                            pass
+                    logger.info("Firefox 已关闭")
+                else:
+                    # 可能是复用的 Firefox 进程，尝试通过 pkill 关闭
+                    try:
+                        subprocess.run(["pkill", "-f", "firefox"], capture_output=True, timeout=5)
+                        logger.info("Firefox 进程已终止 (pkill)")
+                    except Exception:
+                        pass
+            except Exception as e:
+                logger.error(f"关闭 Firefox 异常: {e}")
+            finally:
+                self._firefox_process = None
+                self._firefox_mode = False
+                self._vnc_used = False
+            return SkillResult(success=True, message="Firefox 已关闭")
+
         try:
             if self._browser:
                 self._browser.quit()
@@ -855,6 +1018,10 @@ class StealthBrowser:
         if not self._ensure_page():
             return SkillResult(success=False, error="浏览器未启动")
 
+        # [v1.47.16] Firefox+VNC 模式：通过 subprocess 打开 URL
+        if self._firefox_mode:
+            return self._firefox_navigate(url, wait)
+
         try:
             self._page.get(url)
             if wait > 0:
@@ -960,6 +1127,10 @@ class StealthBrowser:
         if not self._ensure_page():
             return SkillResult(success=False, error="浏览器未启动")
 
+        # [v1.47.16] Firefox+VNC 模式：通过 xdotool 点击
+        if self._firefox_mode:
+            return self._firefox_click(selector, wait)
+
         try:
             ele = self._find_element(selector, timeout=10)
             if not ele:
@@ -1034,6 +1205,10 @@ class StealthBrowser:
         if not self._ensure_page():
             return SkillResult(success=False, error="浏览器未启动")
 
+        # [v1.47.16] Firefox+VNC 模式：通过 xdotool 输入
+        if self._firefox_mode:
+            return self._firefox_fill(selector, value, clear, wait)
+
         try:
             ele = self._find_element(selector, timeout=10)
             if not ele:
@@ -1077,8 +1252,11 @@ class StealthBrowser:
         if not self._ensure_page():
             return SkillResult(success=False, error="浏览器未启动")
 
+        # [v1.47.16] Firefox+VNC 模式：通过 xdotool type 输入
+        if self._firefox_mode:
+            return self._firefox_fill(selector or "", text, clear, wait)
+
         try:
-            # 如果提供了 selector，先点击聚焦
             if selector:
                 ele = self._find_element(selector, timeout=10)
                 if not ele:
@@ -1170,8 +1348,11 @@ class StealthBrowser:
         if not self._ensure_page():
             return SkillResult(success=False, error="浏览器未启动")
 
+        # [v1.47.16] Firefox+VNC 模式：通过 xdotool key 按键
+        if self._firefox_mode:
+            return self._firefox_press_key(key, selector, wait)
+
         try:
-            # 如果提供了 selector，先聚焦
             if selector:
                 ele = self._find_element(selector, timeout=10)
                 if ele:
@@ -1260,6 +1441,10 @@ class StealthBrowser:
         if not self._ensure_page():
             return SkillResult(success=False, error="浏览器未启动")
 
+        # [v1.47.16] Firefox+VNC 模式：通过 ImageMagick import 截图
+        if self._firefox_mode:
+            return self._firefox_screenshot(save_path)
+
         try:
             if not save_path:
                 # 自动生成路径
@@ -1290,6 +1475,13 @@ class StealthBrowser:
         if not self._ensure_page():
             return SkillResult(success=False, error="浏览器未启动")
 
+        # [v1.47.16] Firefox+VNC 模式：无法通过 CDP 执行 JS
+        if self._firefox_mode:
+            return SkillResult(
+                success=False,
+                error="Firefox+VNC 模式下不支持 JS 执行。请在 VNC 中手动操作，或切换到桌面环境使用 Chromium。",
+            )
+
         try:
             _script = script.strip()
             # 检测是否包含 return 语句
@@ -1346,6 +1538,13 @@ class StealthBrowser:
         if not self._ensure_page():
             return SkillResult(success=False, error="浏览器未启动")
 
+        # [v1.47.16] Firefox+VNC 模式：无法获取页面内容
+        if self._firefox_mode:
+            return SkillResult(
+                success=False,
+                error="Firefox+VNC 模式下不支持获取页面内容。请在 VNC 中手动查看，或切换到桌面环境使用 Chromium。",
+            )
+
         try:
             # Bug Fix: DrissionPage 没有 page.text 属性
             # 需要通过 page.ele('tag:html').text 获取页面文本
@@ -1384,6 +1583,13 @@ class StealthBrowser:
         if not self._ensure_page():
             return SkillResult(success=False, error="浏览器未启动")
 
+        # [v1.47.16] Firefox+VNC 模式：无法获取页面 HTML
+        if self._firefox_mode:
+            return SkillResult(
+                success=False,
+                error="Firefox+VNC 模式下不支持获取页面 HTML。请在 VNC 中手动查看，或切换到桌面环境使用 Chromium。",
+            )
+
         try:
             html = self._page.html or ""
             output_html = html[:50000] if len(html) > 50000 else html
@@ -1408,6 +1614,13 @@ class StealthBrowser:
         if not self._ensure_page():
             return SkillResult(success=False, error="浏览器未启动")
 
+        # [v1.47.16] Firefox+VNC 模式：无法等待元素
+        if self._firefox_mode:
+            return SkillResult(
+                success=False,
+                error="Firefox+VNC 模式下不支持等待元素。请在 VNC 中手动操作。",
+            )
+
         try:
             ele = self._find_element(selector, timeout=timeout)
             if ele:
@@ -1428,6 +1641,10 @@ class StealthBrowser:
         if not self._ensure_page():
             return SkillResult(success=False, error="浏览器未启动")
 
+        # [v1.47.16] Firefox+VNC 模式：读取 cookies.sqlite
+        if self._firefox_mode:
+            return self._firefox_get_cookies()
+
         try:
             # DrissionPage cookies() 返回 CookiesList（list 子类），每项是 dict
             cookies = self._page.cookies()
@@ -1458,6 +1675,13 @@ class StealthBrowser:
         if not self._ensure_page():
             return SkillResult(success=False, error="浏览器未启动")
 
+        # [v1.47.16] Firefox+VNC 模式：Cookie 已由 Firefox 自动保存到 profile 目录
+        if self._firefox_mode:
+            return SkillResult(
+                success=True,
+                message="Firefox+VNC 模式: Cookie 由 Firefox 自动保存到 profile 目录",
+            )
+
         try:
             cookies = self._page.cookies()
             cookie_list = []
@@ -1487,6 +1711,13 @@ class StealthBrowser:
         if not self._ensure_page():
             return SkillResult(success=False, error="浏览器未启动")
 
+        # [v1.47.16] Firefox+VNC 模式：Cookie 由 Firefox 自动从 profile 目录加载
+        if self._firefox_mode:
+            return SkillResult(
+                success=True,
+                message="Firefox+VNC 模式: Cookie 由 Firefox 自动从 profile 目录加载",
+            )
+
         try:
             from core.browser_profile import get_browser_profile_manager
             mgr = get_browser_profile_manager()
@@ -1514,6 +1745,10 @@ class StealthBrowser:
         if not self._ensure_page():
             return SkillResult(success=False, error="浏览器未启动")
 
+        # [v1.47.16] Firefox+VNC 模式：删除 cookies.sqlite
+        if self._firefox_mode:
+            return self._firefox_clear_cookies()
+
         try:
             # Bug Fix: DrissionPage 没有 page.clear_cookies() 方法
             # 正确方式是 page.set.cookies.clear() 或 page.clear_cache()
@@ -1553,8 +1788,23 @@ class StealthBrowser:
 
         # Bug Fix: 使用 asyncio.sleep 避免阻塞事件循环
         start = time.time()
-        last_url = self._page.url if self._page else ""
         poll_interval = 3
+
+        # [v1.47.16] Firefox+VNC 模式下简化等待逻辑
+        if self._firefox_mode:
+            while time.time() - start < timeout:
+                await asyncio.sleep(poll_interval)
+                # 检查 Firefox 是否仍在运行
+                if not self._ensure_page():
+                    break
+            elapsed = int(time.time() - start)
+            return SkillResult(
+                success=True,
+                message=f"等待用户手动操作完成 ({reason})，耗时 {elapsed} 秒",
+                data={"elapsed": elapsed},
+            )
+
+        last_url = self._page.url if self._page else ""
         while time.time() - start < timeout:
             await asyncio.sleep(poll_interval)
             if self._page:
@@ -1579,6 +1829,24 @@ class StealthBrowser:
 
     def _ensure_page(self) -> bool:
         """确保浏览器和页面可用"""
+        # [v1.47.16] Firefox+VNC 模式：检查 Firefox 进程是否存活
+        if self._firefox_mode:
+            if not self._started:
+                return False
+            if self._firefox_process and self._firefox_process.poll() is None:
+                return True
+            # 复用的 Firefox，检查进程是否存在
+            try:
+                result = subprocess.run(
+                    ["pgrep", "-f", "firefox"],
+                    capture_output=True, text=True, timeout=3,
+                )
+                if result.returncode == 0 and result.stdout.strip():
+                    return True
+            except Exception:
+                pass
+            return False
+
         if not self._started or not self._page:
             return False
         try:
@@ -1591,6 +1859,352 @@ class StealthBrowser:
             logger.debug(f"页面检查失败 (profile={self.profile_name})，浏览器可能已关闭")
             return False
 
+    # ── [v1.47.16] Firefox+VNC 模式辅助方法 ──────────────────────────
+
+    def _firefox_navigate(self, url: str, wait: float = 2.0) -> SkillResult:
+        """Firefox+VNC 模式下导航到指定 URL。
+
+        Firefox 支持远程打开 URL：firefox <url> 会在已运行的实例中打开新标签页。
+        """
+        display = os.environ.get("DISPLAY", ":99")
+        env = {**os.environ, "DISPLAY": display}
+        if not env.get("G_SLICE"):
+            env["G_SLICE"] = "always-malloc"
+
+        try:
+            firefox_path = shutil.which("firefox") or shutil.which("myagent-browser")
+            if not firefox_path:
+                return SkillResult(success=False, error="Firefox 未找到")
+
+            result = subprocess.run(
+                [firefox_path, "--profile", self._firefox_profile_dir, url],
+                capture_output=True, text=True, timeout=10,
+                env=env, start_new_session=True,
+            )
+            logger.info(f"Firefox 打开 URL: {url}")
+            if wait > 0:
+                time.sleep(wait)
+            return SkillResult(
+                success=True,
+                message=f"Firefox 已打开: {url}",
+                data={"url": url},
+            )
+        except Exception as e:
+            return SkillResult(success=False, error=f"Firefox 导航失败: {e}")
+
+    def _firefox_click(self, selector: str, wait: float = 1.0) -> SkillResult:
+        """Firefox+VNC 模式下通过 xdotool 点击元素。
+
+        限制：只能通过坐标点击，无法像 DrissionPage 精确匹配 CSS 选择器。
+        策略：先用 xdotool search 查找 Firefox 窗口，再尝试通过
+        xdotool key 模拟 Tab+Enter（适用于链接/按钮）。
+        """
+        display = os.environ.get("DISPLAY", ":99")
+        env = {**os.environ, "DISPLAY": display}
+
+        try:
+            # 查找 Firefox 窗口
+            result = subprocess.run(
+                ["xdotool", "search", "--onlyvisible", "--class", "firefox"],
+                capture_output=True, text=True, timeout=5,
+                env=env, start_new_session=True,
+            )
+            if result.returncode != 0 or not result.stdout.strip():
+                return SkillResult(
+                    success=False,
+                    error="Firefox+VNC: 未找到 Firefox 窗口，无法点击。"
+                          "请在 VNC 中确认 Firefox 已打开。",
+                )
+
+            window_id = result.stdout.strip().split()[0]
+            # 激活窗口并点击
+            subprocess.run(
+                ["xdotool", "windowactivate", "--sync", window_id],
+                capture_output=True, timeout=5, env=env, start_new_session=True,
+            )
+            # 如果 selector 是文本，用 Ctrl+F 搜索后按 Enter
+            # 否则直接在窗口中心点击
+            subprocess.run(
+                ["xdotool", "click", "--window", window_id, "1"],
+                capture_output=True, timeout=5, env=env, start_new_session=True,
+            )
+            if wait > 0:
+                time.sleep(wait)
+
+            return SkillResult(
+                success=True,
+                message=f"Firefox+VNC: 已在 Firefox 窗口点击 (selector={selector})。"
+                        f"VNC 模式下点击精度有限，建议手动操作。",
+            )
+        except Exception as e:
+            return SkillResult(
+                success=False,
+                error=f"Firefox+VNC 点击失败: {e}。建议在 VNC 中手动操作。",
+            )
+
+    def _firefox_fill(self, selector: str, value: str, clear: bool = True, wait: float = 0.5) -> SkillResult:
+        """Firefox+VNC 模式下通过 xdotool 填写输入框。
+
+        限制：无法精确定位输入框，需要用户先在 VNC 中点击目标输入框。
+        """
+        display = os.environ.get("DISPLAY", ":99")
+        env = {**os.environ, "DISPLAY": display}
+
+        try:
+            # 查找 Firefox 窗口
+            result = subprocess.run(
+                ["xdotool", "search", "--onlyvisible", "--class", "firefox"],
+                capture_output=True, text=True, timeout=5,
+                env=env, start_new_session=True,
+            )
+            if result.returncode != 0 or not result.stdout.strip():
+                return SkillResult(
+                    success=False,
+                    error="Firefox+VNC: 未找到 Firefox 窗口。请在 VNC 中确认 Firefox 已打开。",
+                )
+
+            window_id = result.stdout.strip().split()[0]
+            subprocess.run(
+                ["xdotool", "windowactivate", "--sync", window_id],
+                capture_output=True, timeout=5, env=env, start_new_session=True,
+            )
+
+            if clear:
+                # Ctrl+A 全选，然后输入新内容替换
+                subprocess.run(
+                    ["xdotool", "key", "--window", window_id, "ctrl+a"],
+                    capture_output=True, timeout=3, env=env, start_new_session=True,
+                )
+                time.sleep(0.2)
+
+            # 使用 xdotool type 输入文本
+            subprocess.run(
+                ["xdotool", "type", "--window", window_id, "--delay", "50", value],
+                capture_output=True, timeout=15, env=env, start_new_session=True,
+            )
+
+            if wait > 0:
+                time.sleep(wait)
+
+            return SkillResult(
+                success=True,
+                message=f"Firefox+VNC: 已输入文本到 Firefox。"
+                        f"请确认输入框已选中（先在 VNC 中点击目标输入框）。",
+            )
+        except Exception as e:
+            return SkillResult(
+                success=False,
+                error=f"Firefox+VNC 输入失败: {e}",
+            )
+
+    def _firefox_press_key(self, key: str, selector: str = "", wait: float = 0.5) -> SkillResult:
+        """[v1.47.16] Firefox+VNC 模式下通过 xdotool key 按键。"""
+        display = os.environ.get("DISPLAY", ":99")
+        env = {**os.environ, "DISPLAY": display}
+
+        try:
+            # 查找 Firefox 窗口
+            result = subprocess.run(
+                ["xdotool", "search", "--onlyvisible", "--class", "firefox"],
+                capture_output=True, text=True, timeout=5,
+                env=env, start_new_session=True,
+            )
+            if result.returncode != 0 or not result.stdout.strip():
+                return SkillResult(
+                    success=False,
+                    error="Firefox+VNC: 未找到 Firefox 窗口。请在 VNC 中确认 Firefox 已打开。",
+                )
+
+            window_id = result.stdout.strip().split()[0]
+            subprocess.run(
+                ["xdotool", "windowactivate", "--sync", window_id],
+                capture_output=True, timeout=5, env=env, start_new_session=True,
+            )
+
+            # 将 JS 按键名称映射为 xdotool 按键名称
+            xdotool_key_map = {
+                'enter': 'Return', 'tab': 'Tab', 'escape': 'Escape', 'esc': 'Escape',
+                'backspace': 'BackSpace', 'delete': 'Delete', 'del': 'Delete',
+                'arrowup': 'Up', 'arrowdown': 'Down', 'arrowleft': 'Left', 'arrowright': 'Right',
+                'up': 'Up', 'down': 'Down', 'left': 'Left', 'right': 'Right',
+                'home': 'Home', 'end': 'End',
+                'pageup': 'Page_Up', 'pagedown': 'Page_Down',
+                'space': 'space', ' ': 'space',
+                'ctrl': 'ctrl', 'shift': 'shift', 'alt': 'alt', 'meta': 'super',
+                'cmd': 'super', 'command': 'super',
+            }
+            # F1-F12
+            for i in range(1, 13):
+                xdotool_key_map[f'f{i}'] = f'F{i}'
+
+            # 解析组合键
+            parts = key.strip().split('+')
+            xdotool_keys = []
+            for part in parts:
+                p = part.strip()
+                mapped = xdotool_key_map.get(p.lower(), p)
+                xdotool_keys.append(mapped)
+
+            # 构建 xdotool key 参数
+            xdotool_key_str = '+'.join(xdotool_keys)
+            subprocess.run(
+                ["xdotool", "key", "--window", window_id, xdotool_key_str],
+                capture_output=True, timeout=5, env=env, start_new_session=True,
+            )
+
+            if wait > 0:
+                time.sleep(wait)
+
+            return SkillResult(
+                success=True,
+                message=f"Firefox+VNC: 已按键: {key}",
+            )
+        except Exception as e:
+            return SkillResult(
+                success=False,
+                error=f"Firefox+VNC 按键失败: {e}",
+            )
+
+    def _firefox_screenshot(self, save_path: str = "") -> SkillResult:
+        """Firefox+VNC 模式下通过 xdotool + import 截图。"""
+        display = os.environ.get("DISPLAY", ":99")
+        env = {**os.environ, "DISPLAY": display}
+
+        try:
+            if not save_path:
+                from core.browser_profile import get_browser_profile_manager
+                save_dir = get_browser_profile_manager().base_dir / "screenshots"
+                os.makedirs(save_dir, exist_ok=True)
+                timestamp = time.strftime("%Y%m%d_%H%M%S")
+                save_path = str(save_dir / f"firefox_{timestamp}.png")
+
+            # 方法1: 使用 ImageMagick import 截取整个屏幕
+            import_cmd = shutil.which("import")
+            if import_cmd:
+                result = subprocess.run(
+                    [import_cmd, "-window", "root", "-display", display, save_path],
+                    capture_output=True, timeout=10,
+                    env=env, start_new_session=True,
+                )
+                if result.returncode == 0 and os.path.isfile(save_path):
+                    logger.info(f"Firefox 截图已保存: {save_path}")
+                    return SkillResult(
+                        success=True,
+                        message=f"Firefox+VNC 截图已保存",
+                        data={"path": save_path},
+                    )
+
+            # 方法2: 使用 xdotool + scrot
+            scrot_cmd = shutil.which("scrot")
+            if scrot_cmd:
+                result = subprocess.run(
+                    [scrot_cmd, save_path],
+                    capture_output=True, timeout=10,
+                    env=env, start_new_session=True,
+                )
+                if result.returncode == 0 and os.path.isfile(save_path):
+                    logger.info(f"Firefox 截图已保存 (scrot): {save_path}")
+                    return SkillResult(
+                        success=True,
+                        message=f"Firefox+VNC 截图已保存 (scrot)",
+                        data={"path": save_path},
+                    )
+
+            # 方法3: 使用 xwd + convert
+            xwd_cmd = shutil.which("xwd")
+            convert_cmd = shutil.which("convert")
+            if xwd_cmd and convert_cmd:
+                xwd_tmp = save_path + ".xwd"
+                result = subprocess.run(
+                    [xwd_cmd, "-root", "-display", display, "-out", xwd_tmp],
+                    capture_output=True, timeout=10,
+                    env=env, start_new_session=True,
+                )
+                if result.returncode == 0:
+                    subprocess.run(
+                        [convert_cmd, xwd_tmp, save_path],
+                        capture_output=True, timeout=10,
+                        env=env, start_new_session=True,
+                    )
+                    try:
+                        os.unlink(xwd_tmp)
+                    except Exception:
+                        pass
+                    if os.path.isfile(save_path):
+                        logger.info(f"Firefox 截图已保存 (xwd+convert): {save_path}")
+                        return SkillResult(
+                            success=True,
+                            message=f"Firefox+VNC 截图已保存",
+                            data={"path": save_path},
+                        )
+
+            return SkillResult(
+                success=False,
+                error="Firefox+VNC 截图失败: 没有可用的截图工具 "
+                      "(需要 ImageMagick import / scrot / xwd+convert)",
+            )
+        except Exception as e:
+            return SkillResult(success=False, error=f"Firefox+VNC 截图失败: {e}")
+
+    def _firefox_get_cookies(self) -> SkillResult:
+        """Firefox+VNC 模式下读取 cookies.sqlite。"""
+        try:
+            import sqlite3
+            cookies_db = os.path.join(self._firefox_profile_dir, "cookies.sqlite")
+            if not os.path.isfile(cookies_db):
+                return SkillResult(
+                    success=True,
+                    message="Firefox Profile 中没有 cookies.sqlite",
+                    data={"cookies": []},
+                )
+
+            # Firefox 使用 WAL 模式，需要先 checkpoint 或复制文件再读取
+            # 直接读取可能会锁冲突，先复制到临时文件
+            import tempfile
+            with tempfile.NamedTemporaryFile(suffix=".sqlite", delete=False) as tmp:
+                tmp_path = tmp.name
+            shutil.copy2(cookies_db, tmp_path)
+
+            try:
+                conn = sqlite3.connect(tmp_path)
+                cursor = conn.cursor()
+                cursor.execute("SELECT name, value, host, path FROM moz_cookies")
+                rows = cursor.fetchall()
+                conn.close()
+
+                cookie_list = []
+                for row in rows:
+                    cookie_list.append({
+                        "name": row[0],
+                        "value": row[1],
+                        "domain": row[2],
+                        "path": row[3],
+                    })
+
+                return SkillResult(
+                    success=True,
+                    message=f"读取到 {len(cookie_list)} 个 Cookie",
+                    data={"cookies": cookie_list},
+                )
+            finally:
+                try:
+                    os.unlink(tmp_path)
+                except Exception:
+                    pass
+        except Exception as e:
+            return SkillResult(success=False, error=f"Firefox 读取 Cookie 失败: {e}")
+
+    def _firefox_clear_cookies(self) -> SkillResult:
+        """Firefox+VNC 模式下清除 cookies.sqlite。"""
+        try:
+            cookies_db = os.path.join(self._firefox_profile_dir, "cookies.sqlite")
+            if os.path.isfile(cookies_db):
+                os.remove(cookies_db)
+                logger.info("Firefox cookies.sqlite 已删除")
+            return SkillResult(success=True, message="Firefox Cookie 已清除")
+        except Exception as e:
+            return SkillResult(success=False, error=f"Firefox 清除 Cookie 失败: {e}")
+
     def _log_chrome_cmdline(self) -> None:
         """[DEBUG] 获取 Chrome 实际进程的命令行，验证 --user-data-dir 是否正确。"""
         import re
@@ -1824,11 +2438,16 @@ class StealthBrowser:
         return False
 
     @staticmethod
-    def _detect_browser() -> Optional[str]:
+    def _detect_browser(skip_puppeteer: bool = False) -> Optional[str]:
         """自动检测 Chromium/Chrome 浏览器路径
 
         [v1.47.10] 增加 snap 包装器检测：proot 下 snap 不可用，
         跳过 snap 包装脚本，避免浏览器启动后无法连接。
+
+        [v1.47.16] 增加 skip_puppeteer 参数：VNC/Termux 模式下
+        Puppeteer Chrome 在 proot ARM64 下不可用（DrissionPage 报
+        "The browser executable file path cannot be found"），
+        跳过以避免无效启动尝试。
         """
         # 1. 环境变量
         for key in ("CHROME_PATH", "BROWSER_PATH", "CHROMIUM_PATH"):
@@ -1892,17 +2511,22 @@ class StealthBrowser:
                     return p
 
         # 4. Puppeteer / Playwright 缓存
-        for cache in (
-            os.path.join(home, ".cache", "puppeteer", "chrome"),
-            os.path.join(home, ".cache", "ms-playwright"),
-        ):
-            if os.path.isdir(cache):
-                for root, _, files in os.walk(cache):
-                    for fname in files:
-                        if fname in ("chrome", "chromium", "headless_shell"):
-                            full = os.path.join(root, fname)
-                            if os.access(full, os.X_OK):
-                                return full
+        # [v1.47.16] VNC/Termux 模式下跳过：Puppeteer Chrome 在 proot ARM64 下
+        # 与 DrissionPage 不兼容（报 "browser executable file path cannot be found"）
+        if not skip_puppeteer:
+            for cache in (
+                os.path.join(home, ".cache", "puppeteer", "chrome"),
+                os.path.join(home, ".cache", "ms-playwright"),
+            ):
+                if os.path.isdir(cache):
+                    for root, _, files in os.walk(cache):
+                        for fname in files:
+                            if fname in ("chrome", "chromium", "headless_shell"):
+                                full = os.path.join(root, fname)
+                                if os.access(full, os.X_OK):
+                                    return full
+        else:
+            logger.info("[_detect_browser] VNC/Termux 模式: 跳过 Puppeteer/Playwright 缓存浏览器 (proot ARM64 不可用)")
 
         return None
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "myagent-ai",
-  "version": "1.47.15",
+  "version": "1.47.17",
   "description": "本地桌面端执行型AI助手 - Open Interpreter 风格 | Local Desktop Execution-Oriented AI Assistant",
   "main": "main.py",
   "bin": {