myagent-ai 1.20.4 → 1.20.6

package/agents/main_agent.py

@@ -7,6 +7,7 @@ from __future__ import annotations
 
 import asyncio
 import json
+import os
 import re
 from typing import Any, Callable, Dict, List, Optional
 
@@ -76,6 +77,18 @@ class MainAgent(BaseAgent):
 - **发送文件给用户**: 用 `file_send` 工具（参数: file_path=文件路径, description=说明），当你生成或处理了文件需要返回给用户时使用
 - **播放音频**: 用 `playaudio` 工具（参数: url=音乐链接或file_path=本地文件路径），在聊天中内嵌播放音频（支持QQ音乐、YouTube音乐、本地MP3/WAV等），播放时自动关闭语音合成
 - **播放视频**: 用 `playvideo` 工具（参数: url=视频链接或file_path=本地文件路径），在聊天中内嵌播放视频（支持抖音、YouTube、B站、本地MP4等），播放时自动关闭语音合成
+- **网页控制**: 用 `web_control` 工具在聊天中打开一个可控制的浏览器面板，可浏览网页、点击元素、填写表单、滚动页面、执行JS、管理Cookie等。
+  - 打开: `{"action": "open", "url": "https://example.com"}` — 首次使用会自动创建会话，后续可传 session_id 复用
+  - 导航: `{"action": "navigate", "url": "https://...", "session_id": "xxx"}`
+  - 获取内容: `{"action": "get_content", "what": "text|html|url|title|links|images|forms|inputs", "session_id": "xxx"}`
+  - 点击元素: `{"action": "click", "selector": "CSS选择器", "session_id": "xxx"}`
+  - 填写输入: `{"action": "fill", "selector": "CSS选择器", "value": "内容", "session_id": "xxx"}`
+  - 滚动页面: `{"action": "scroll", "direction": "up|down|top|bottom", "distance": 300, "session_id": "xxx"}`
+  - 执行JS: `{"action": "evaluate", "script": "JavaScript代码", "session_id": "xxx"}`
+  - 管理Cookie: `{"action": "set_cookies", "cookies": [{"name":"k","value":"v","domain":"example.com"}], "session_id": "xxx"}` 或 `{"action": "get_cookies", "session_id": "xxx"}`
+  - 等待: `{"action": "wait", "time": 1000}` 毫秒 或 `{"action": "wait", "selector": ".result", "timeout": 10}` 秒
+  - 关闭: `{"action": "close", "session_id": "xxx"}`
+  - 注意: 网页通过服务端代理加载，用户可在面板中手动操作。复杂交互建议先用 get_content 查看页面结构再用 click/fill。
 - **主动召回记忆**: 用 `recall_memory` 工具（参数: keyword=关键字, time_point=可选时间点如"2025-01", limit=数量默认5），根据关键字和时间搜索历史记忆
 4. 准备好内容后，最后，再检查输出格式，确保满足以下要求:
 <output>
@@ -1216,6 +1229,7 @@ class MainAgent(BaseAgent):
                 tool_result = await self._execute_v2_tool(
                     tool_name, parms, timeout, context, task_id,
                     stream_callback=stream_callback,
+                    sent_files=_sent_files,
                 )
 
                 # 发送工具结果事件
@@ -1552,6 +1566,7 @@ class MainAgent(BaseAgent):
         context: AgentContext,
         task_id: str,
         stream_callback: Optional[Callable] = None,
+        sent_files: Optional[List[Dict[str, Any]]] = None,
     ) -> Dict[str, Any]:
         """V2 工具执行"""
         result = {"success": False, "output": "", "error": ""}
@@ -1634,18 +1649,14 @@ class MainAgent(BaseAgent):
                     # [v1.16.18] 使用当前作用域的 stream_callback（而非 context._stream_callback）
                     _fresult = await _fskill.execute(_fpath, _fdesc, stream_callback=stream_callback)
                     result = {"success": True, "output": json.dumps(_fresult, ensure_ascii=False, indent=2), "data": _fresult}
-                    # [v1.18.5] 追踪发送的文件，用于持久化到会话记忆
-                    # [v1.18.9] 修复：_sent_files 可能不在作用域内，安全处理
-                    try:
-                        if _fresult.get("success") and _fresult.get("file_id"):
-                            _sent_files.append({
-                                "id": _fresult["file_id"],
-                                "name": _fresult.get("name", ""),
-                                "type": _fresult.get("type", ""),
-                                "size": _fresult.get("size", 0),
-                            })
-                    except NameError:
-                        pass  # _sent_files 不在当前作用域，跳过文件追踪
+                    # [v1.18.5→21.1] 追踪发送的文件，用于持久化到会话记忆
+                    if sent_files is not None and _fresult.get("success") and _fresult.get("file_id"):
+                        sent_files.append({
+                            "id": _fresult["file_id"],
+                            "name": _fresult.get("name", ""),
+                            "type": _fresult.get("type", ""),
+                            "size": _fresult.get("size", 0),
+                        })
                 except Exception as _fse:
                     result = {"success": False, "error": f"文件发送失败: {_fse}"}
                     logger.warning(f"[{task_id}] file_send 工具异常: {_fse}")
@@ -1727,17 +1738,14 @@ class MainAgent(BaseAgent):
                                 # 标记为媒体文件，前端渲染内嵌播放器
                                 _fresult["_media_type"] = _media_type
                                 result = {"success": True, "output": f"已发送{_media_type}文件: {_fpath.name}", "data": _fresult}
-                                try:
-                                    if _fresult.get("file_id"):
-                                        _sent_files.append({
-                                            "id": _fresult["file_id"],
-                                            "name": _fresult.get("name", ""),
-                                            "type": _fresult.get("type", ""),
-                                            "size": _fresult.get("size", 0),
-                                            "_media_type": _media_type,
-                                        })
-                                except NameError:
-                                    pass
+                                if sent_files is not None and _fresult.get("file_id"):
+                                    sent_files.append({
+                                        "id": _fresult["file_id"],
+                                        "name": _fresult.get("name", ""),
+                                        "type": _fresult.get("type", ""),
+                                        "size": _fresult.get("size", 0),
+                                        "_media_type": _media_type,
+                                    })
                             else:
                                 result = {"success": False, "error": _fresult.get("error", "文件发送失败")}
                     else:
@@ -1747,12 +1755,138 @@ class MainAgent(BaseAgent):
                     result = {"success": False, "error": f"播放工具异常: {_me}"}
                     logger.warning(f"[{task_id}] {tool_name} 工具异常: {_me}")
 
+            elif tool_name == "web_control":
+                # [v1.21.0] 网页控制器 — 在聊天中打开可控制的浏览器面板
+                try:
+                    from core.web_control import get_web_control_manager
+                    _wc_mgr = get_web_control_manager()
+                    _wc_action = params.get("action", "open")
+                    _wc_session_id = params.get("session_id", "").strip()
+
+                    # 自动获取或创建会话
+                    _wc_session = None
+                    if _wc_session_id:
+                        _wc_session = _wc_mgr.get_session(_wc_session_id)
+                    if not _wc_session:
+                        _wc_session = _wc_mgr.create_session()
+                        _wc_session_id = _wc_session.session_id
+
+                    if _wc_action == "open":
+                        # 打开面板 — 发送 SSE 事件让前端弹出控制面板
+                        _wc_url = params.get("url", "").strip()
+                        if _wc_url:
+                            _wc_session.current_url = _wc_url
+                        if stream_callback:
+                            stream_callback({
+                                "type": "v2_web_control",
+                                "data": {
+                                    "action": "open",
+                                    "session_id": _wc_session_id,
+                                    "url": _wc_url,
+                                    "panel_url": f"/api/web_control/panel?sid={_wc_session_id}",
+                                }
+                            })
+                        result = {
+                            "success": True,
+                            "output": f"已打开网页控制面板 (session: {_wc_session_id})" + (f"，URL: {_wc_url}" if _wc_url else ""),
+                            "session_id": _wc_session_id,
+                        }
+
+                    elif _wc_action == "close":
+                        _wc_mgr.close_session(_wc_session_id)
+                        if stream_callback:
+                            stream_callback({
+                                "type": "v2_web_control",
+                                "data": {"action": "close", "session_id": _wc_session_id}
+                            })
+                        result = {"success": True, "output": f"已关闭网页控制面板 (session: {_wc_session_id})"}
+
+                    elif _wc_action == "navigate":
+                        _wc_url = params.get("url", "").strip()
+                        if not _wc_url:
+                            result = {"success": False, "error": "请提供 url 参数"}
+                        else:
+                            _wc_session.current_url = _wc_url
+                            if stream_callback:
+                                stream_callback({
+                                    "type": "v2_web_control",
+                                    "data": {"action": "navigate", "session_id": _wc_session_id, "url": _wc_url}
+                                })
+                            result = {"success": True, "output": f"正在导航到: {_wc_url}"}
+
+                    elif _wc_action in ("set_cookies", "get_cookies"):
+                        # Cookie 操作 — 服务端直接处理
+                        if _wc_action == "set_cookies":
+                            _cookies = params.get("cookies", [])
+                            if isinstance(_cookies, str):
+                                import json as _jc
+                                try:
+                                    _cookies = _jc.loads(_cookies)
+                                except:
+                                    _cookies = []
+                            for _c in _cookies:
+                                if isinstance(_c, dict):
+                                    _c_domain = _c.get("domain", "").lstrip(".")
+                                    _c_name = _c.get("name", "")
+                                    _c_value = _c.get("value", "")
+                                    if _c_domain and _c_name:
+                                        _wc_session.cookies[f"{_c_domain}::{_c_name}"] = _c_value
+                            result = {"success": True, "output": f"已设置 {len(_cookies)} 个 cookie", "total_cookies": len(_wc_session.cookies)}
+                        else:
+                            _cookie_list = []
+                            for _ck, _cv in _wc_session.cookies.items():
+                                _parts = _ck.split("::", 1)
+                                if len(_parts) == 2:
+                                    _cookie_list.append({"domain": _parts[0], "name": _parts[1], "value": _cv})
+                            result = {"success": True, "output": json.dumps(_cookie_list, ensure_ascii=False), "cookies": _cookie_list}
+
+                    else:
+                        # 其他操作（click, fill, scroll, evaluate, get_content, wait, screenshot）
+                        # 通过命令队列下发到客户端执行，阻塞等待结果
+                        _wc_params = {k: v for k, v in params.items() if k not in ("action", "session_id")}
+                        _wc_timeout = int(params.get("timeout", timeout))
+                        _wc_result = await _wc_mgr.queue_command(
+                            session_id=_wc_session_id,
+                            action=_wc_action,
+                            params=_wc_params,
+                            timeout=min(_wc_timeout, 60),  # 最大 60 秒
+                        )
+                        result = _wc_result
+
+                except Exception as _wce:
+                    result = {"success": False, "error": f"网页控制器异常: {_wce}"}
+                    logger.warning(f"[{task_id}] web_control 工具异常: {_wce}")
+
             elif self.skills:
                 exec_result = await self.skills.execute(tool_name, **params)
                 if exec_result is None:
                     result["error"] = f"技能 {tool_name} 返回了空结果"
                 else:
                     result = exec_result.to_dict()
+                    # [v1.21.1] Skill 生成文件后自动通过 file_send 发送给前端
+                    if exec_result.success and exec_result.files:
+                        try:
+                            from skills.file_send import FileSendSkill
+                            _auto_fsend = FileSendSkill()
+                            for _auto_fpath in exec_result.files:
+                                if _auto_fpath and os.path.isfile(_auto_fpath):
+                                    _auto_fres = await _auto_fsend.execute(
+                                        _auto_fpath, stream_callback=stream_callback)
+                                    if _auto_fres.get("success") and _auto_fres.get("file_id"):
+                                        # 记录发送的 file_id
+                                        if not result.get("_sent_file_ids"):
+                                            result["_sent_file_ids"] = []
+                                        result["_sent_file_ids"].append(_auto_fres["file_id"])
+                                        # 追踪到 sent_files（持久化到会话记忆）
+                                        if sent_files is not None:
+                                            sent_files.append({
+                                                "id": _auto_fres["file_id"],
+                                                "name": _auto_fres.get("name", ""),
+                                                "type": _auto_fres.get("type", ""),
+                                                "size": _auto_fres.get("size", 0),
+                                            })
+                        except Exception as _afe:
+                            logger.warning(f"[{task_id}] 自动 file_send 失败: {_afe}")
             else:
                 result["error"] = f"未知工具: {tool_name}"
 

package/core/vnc_manager.py

@@ -371,6 +371,62 @@ class VNCManager:
 
         return None
 
+    def _ensure_dev_shm(self) -> None:
+        """[v1.20.5] 检查并修复 /dev/shm 挂载（Termux proot-distro 环境下常见问题）。
+        
+        Android 对 SysV IPC / 共享内存有限制，导致 x11vnc 的 shmget() 失败。
+        即使加了 -noshm，某些 x11vnc 版本仍会尝试访问 /dev/shm，
+        所以提前确保目录存在且有正确权限。
+        """
+        shm_path = "/dev/shm"
+        try:
+            if not os.path.exists(shm_path):
+                logger.info(f"/dev/shm 不存在，尝试创建...")
+                os.makedirs(shm_path, exist_ok=True)
+                try:
+                    os.chmod(shm_path, 0o1777)
+                    logger.info("/dev/shm 创建成功，权限设为 1777")
+                except OSError as e:
+                    logger.warning(f"/dev/shm chmod 失败 (proot 环境可能无权限): {e}")
+            else:
+                # 检查权限
+                st = os.stat(shm_path)
+                if st.st_mode & 0o777 != 0o777:
+                    try:
+                        os.chmod(shm_path, 0o1777)
+                        logger.info(f"/dev/shm 权限已修正为 1777")
+                    except OSError as e:
+                        logger.warning(f"/dev/shm chmod 失败: {e}")
+        except Exception as e:
+            logger.warning(f"/dev/shm 检查异常: {e}")
+
+    def _kill_port_users(self, port: int) -> None:
+        """[v1.20.5] 强制清理占用指定端口的残留进程（Termux 环境下进程管理不彻底）。
+        
+        依次尝试: fuser -k → pkill -9 → fallback pgrep+kill
+        """
+        # 方法1: fuser -k（最彻底，直接杀掉占用端口的进程）
+        try:
+            result = subprocess.run(
+                ["fuser", "-k", f"{port}/tcp"],
+                capture_output=True, text=True, timeout=5,
+            )
+            if result.returncode == 0:
+                logger.info(f"fuser -k {port}/tcp 执行成功")
+        except (FileNotFoundError, Exception) as e:
+            logger.debug(f"fuser -k 不可用或失败: {e}")
+
+    def _kill_process_by_name(self, name: str) -> None:
+        """[v1.20.5] 按进程名强制杀死所有匹配进程（pkill -9）。"""
+        try:
+            subprocess.run(
+                ["pkill", "-9", name],
+                capture_output=True, text=True, timeout=5,
+            )
+            logger.debug(f"pkill -9 {name} 已执行")
+        except (FileNotFoundError, Exception) as e:
+            logger.debug(f"pkill -9 {name} 失败: {e}")
+
     async def start(self) -> Dict[str, Any]:
         """启动 VNC 远程桌面服务。
         
@@ -397,6 +453,9 @@ class VNCManager:
             if not ok:
                 return {"success": False, "message": f"依赖检查失败: {dep_msg}"}
 
+            # Step 1.5: [v1.20.5] 检查 /dev/shm 挂载（Termux proot-distro 兼容）
+            self._ensure_dev_shm()
+
             # Step 2: 启动或附加 Xvfb
             xvfb_ok = await self._start_xvfb()
             if not xvfb_ok:
@@ -661,89 +720,67 @@ class VNCManager:
     async def _start_x11vnc(self) -> bool:
         """启动 x11vnc VNC 服务器"""
         try:
-            # [v1.18.9] 启动前检查端口是否被占用，清理残留进程
+            # [v1.20.5] 增强端口清理：fuser -k + pkill -9（Termux 环境下进程管理不彻底）
             if self._is_port_listening(self.x11vnc_port):
-                logger.warning(f"端口 {self.x11vnc_port} 已被占用，尝试清理残留 x11vnc 进程...")
-                try:
-                    _result = subprocess.run(
-                        ["pgrep", "-f", f"x11vnc.*{self.display}"],
-                        capture_output=True, text=True, timeout=5,
-                    )
-                    if _result.returncode == 0 and _result.stdout.strip():
-                        for _pid_str in _result.stdout.strip().split("\n"):
-                            try:
-                                _pid = int(_pid_str.strip())
-                                os.kill(_pid, signal.SIGTERM)
-                                logger.info(f"杀死残留 x11vnc PID={_pid}")
-                            except (ValueError, ProcessLookupError):
-                                pass
-                        await asyncio.sleep(1.0)
-                        # SIGTERM 后仍占用则 SIGKILL
-                        if self._is_port_listening(self.x11vnc_port):
+                logger.warning(f"端口 {self.x11vnc_port} 已被占用，清理残留进程...")
+                self._kill_port_users(self.x11vnc_port)
+                self._kill_process_by_name("x11vnc")
+                self._kill_process_by_name("Xvfb")
+                await asyncio.sleep(1.0)
+                # 二次确认
+                if self._is_port_listening(self.x11vnc_port):
+                    # 回退到 pgrep + kill 方式
+                    try:
+                        _result = subprocess.run(
+                            ["pgrep", "-f", f"x11vnc.*{self.display}"],
+                            capture_output=True, text=True, timeout=5,
+                        )
+                        if _result.returncode == 0 and _result.stdout.strip():
                             for _pid_str in _result.stdout.strip().split("\n"):
                                 try:
                                     os.kill(int(_pid_str.strip()), signal.SIGKILL)
+                                    logger.info(f"SIGKILL 残留 x11vnc PID={_pid_str.strip()}")
                                 except (ValueError, ProcessLookupError):
                                     pass
                             await asyncio.sleep(0.5)
-                        if self._is_port_listening(self.x11vnc_port):
-                            logger.warning(f"端口 {self.x11vnc_port} 仍被占用，但可能是旧进程，继续尝试启动")
-                    else:
-                        logger.debug(f"端口 {self.x11vnc_port} 被占用但未找到 display={self.display} 的 x11vnc 进程")
-                except Exception as _e:
-                    logger.debug(f"清理残留 x11vnc 异常: {_e}")
-
-            # [v1.17.2] 处理 x11vnc 0.9.17+ 的 shm-helper 兼容问题
-            # 新版 x11vnc 编译时默认启用 shm-helper，但运行时需要绝对路径
-            # 查找 shm-helper 绝对路径
-            shm_helper = None
-            shm_candidates = [
-                "/usr/lib/x11vnc/shm-helper",
-                "/usr/lib/x11vnc0.9/shm-helper",
-                "/usr/libexec/x11vnc/shm-helper",
-                "/usr/local/lib/x11vnc/shm-helper",
-            ]
-            for _path in shm_candidates:
-                if os.path.isfile(_path):
-                    shm_helper = _path
-                    break
-            if not shm_helper:
-                import shutil as _shutil
-                shm_helper = _shutil.which("x11vnc-shm-helper") or _shutil.which("shm-helper")
-
+                    except Exception as _e:
+                        logger.debug(f"pgrep 清理异常: {_e}")
+                    if self._is_port_listening(self.x11vnc_port):
+                        logger.warning(f"端口 {self.x11vnc_port} 仍被占用，可能被其他服务占用")
+
+            # [v1.20.5] x11vnc 启动参数
+            # 关键: -noshm 禁用共享内存 — Android/Termux proot-distro 环境下
+            # SysV IPC (shmget) 不受支持，不加此参数会导致 shmget failed 错误
+            # 注意: 参数是 -noshm（无横杠分隔），不是 -no-shm
             cmd = [
                 "x11vnc",
                 "-display", self.display,
-                "-forever",      # 持续运行
-                "-shared",       # 允许多个客户端同时连接
-                "-nopw",         # 无密码（本地使用）
+                "-noshm",             # [v1.20.5] 禁用共享内存（Termux proot-distro 必需）
+                "-forever",           # 持续运行
+                "-shared",            # 允许多个客户端同时连接
+                "-nopw",              # 无密码（本地使用）
                 "-rfbport", str(self.x11vnc_port),
                 "-listen", "127.0.0.1",  # 仅本地监听（安全）
-                "-xkb",          # 使用 XKB 扩展
-                "-noxdamage",    # 禁用 XDAMAGE（兼容性更好）
-                "-nowf",         # 禁用 wireframe
-                "-nowcr",        # 禁用 cursor shape updates
+                "-xkb",               # 使用 XKB 扩展
+                "-noxdamage",         # 禁用 XDAMAGE（兼容性更好）
+                "-nowf",              # 禁用 wireframe
+                "-nowcr",             # 禁用 cursor shape updates
                 "-nocursorshape",
-                "-deferupdate", "5",   # 延迟更新（降低带宽）
-                "-scale", "2/3",       # 缩小 2/3（降低带宽）
+                "-deferupdate", "5",  # 延迟更新（降低带宽）
+                "-scale", "2/3",      # 缩小 2/3（降低带宽）
             ]
 
             # [v1.18.5] 不使用 -threads 模式：与 -scale 组合在 0.9.17 中
             # 会导致父进程 fork 后立即退出，端口延迟监听
 
-            # [v1.19.1] 处理 shm-helper: 找到就传绝对路径，找不到就跳过
-            # 注意: x11vnc 0.9.17 不支持 -no-shm 参数，会报 unrecognized option
-            if shm_helper:
-                cmd.extend(["-shm-helper", shm_helper])
-                logger.info(f"x11vnc shm-helper: {shm_helper}")
-            else:
-                logger.info("x11vnc 未找到 shm-helper，跳过 SHM 相关参数")
+            # [v1.20.5] 移除 shm-helper 逻辑 — 改用 -noshm 完全跳过共享内存
+            # 旧版本 (v1.17.2 ~ v1.20.4) 尝试查找 shm-helper 并传绝对路径，
+            # 但在 Termux 环境下找不到该文件会导致 "expected absolute path" 错误
 
             env = {**os.environ, "DISPLAY": self.display}
 
-            # [v1.18.0] proot/Termux 兼容: 可能需要额外的安全参数
+            # [v1.18.0] proot/Termux 兼容
             cmd.append("-nobell")
-            # 跳过 Xinerama 检查（proot 环境下可能失败）
             env["X11VNC_NO_UNIXPW"] = "1"
 
             logger.info(f"启动 x11vnc: {' '.join(cmd)}")
@@ -826,10 +863,11 @@ class VNCManager:
             except Exception:
                 pass
 
-            # 第二次尝试使用更保守的参数（去掉 -scale、-noxfixes 等可能的问题参数）
+            # 第二次尝试使用更保守的参数（去掉 -scale 等可能的问题参数，保留 -noshm）
             cmd = [
                 "x11vnc",
                 "-display", self.display,
+                "-noshm",             # [v1.20.5] Termux proot-distro 必需
                 "-forever",
                 "-shared",
                 "-nopw",