myagent-ai 1.47.14 → 1.47.16

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()
@@ -634,6 +638,10 @@ class StealthBrowser:
                             self._xvfb_started_by_us = display.get("xvfb_standalone", False)
                             if self._vnc_used:
                                 logger.info(f"复用 VNC 远程桌面显示 ({display['display']}），可在 VNC 中查看浏览器操作")
+                                # [v1.47.16] VNC 模式下直接用 Firefox，不走 DrissionPage/Chromium
+                                # Chromium 在 proot ARM64 下与 DrissionPage 不兼容
+                                logger.info("VNC 模式: 直接启动 Firefox（跳过 Chromium 检测）")
+                                return self._start_firefox_in_vnc()
                         else:
                             # ── Termux+Ubuntu: VNC 失败 → 直接报错，不降级 headless ──
                             if _is_termux_env:
@@ -657,6 +665,10 @@ class StealthBrowser:
                         if display:
                             self._vnc_used = display.get("vnc", False)
                             self._xvfb_started_by_us = display.get("xvfb_standalone", False)
+                            if self._vnc_used:
+                                # [v1.47.16] VNC 模式下直接用 Firefox
+                                logger.info("VNC 模式 (env_detect不可用): 直接启动 Firefox")
+                                return self._start_firefox_in_vnc()
                         else:
                             if _is_termux_env:
                                 return SkillResult(
@@ -681,7 +693,9 @@ class StealthBrowser:
                         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']})")
+                            # [v1.47.16] VNC 模式下直接用 Firefox
+                            logger.info(f"Termux+Ubuntu VNC 模式: 直接启动 Firefox")
+                            return self._start_firefox_in_vnc()
                     else:
                         return SkillResult(
                             success=False,
@@ -818,9 +832,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 +1039,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 +1148,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 +1226,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:
@@ -1260,6 +1456,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:
                 # 自动生成路径
@@ -1428,6 +1628,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()
@@ -1514,6 +1718,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 +1761,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 +1802,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 +1832,284 @@ 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_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 +2343,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 +2416,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.14",
+  "version": "1.47.16",
   "description": "本地桌面端执行型AI助手 - Open Interpreter 风格 | Local Desktop Execution-Oriented AI Assistant",
   "main": "main.py",
   "bin": {

package/web/ui/chat/flow_engine.js

@@ -1374,8 +1374,11 @@ async function sendMessage(opts) {
 
   // [v1.23.35] Create session if needed — 使用 UUID 防止 ID 重复/乱串
   let sessionId = state.activeSessionId;
-  // [v1.25.5] 如果 activeSessionId 为空，等待 loadSessions 完成确保会话绑定正确
-  if ((!sessionId || sessionId === '__new__') && typeof loadSessions === 'function' && state.activeAgent) {
+  // [v1.47.14] 修复：新对话状态下不调用 loadSessions()！
+  // loadSessions() 会通过 _pendingSessionRestore 或 URL 参数 auto-select
+  // 历史会话，导致用户在"新对话"页面发消息时被跳转到历史会话。
+  // 只有 activeSessionId 完全为空（不是 '__new__'）时才需要等待 loadSessions。
+  if (!sessionId && sessionId !== '__new__' && typeof loadSessions === 'function' && state.activeAgent) {
     console.log('[sendMessage] activeSessionId is empty, waiting for loadSessions...');
     await loadSessions();
     sessionId = state.activeSessionId;