myagent-ai 1.23.45 → 1.23.47

package/core/vnc_manager.py

@@ -76,11 +76,13 @@ class VNCManager:
         self._xvfb_process: Optional[subprocess.Popen] = None
         self._x11vnc_process: Optional[subprocess.Popen] = None
         self._websockify_process: Optional[subprocess.Popen] = None
+        self._wm_process: Optional[subprocess.Popen] = None  # [v1.23.45] 窗口管理器进程
 
         # 状态标记
         self._running = False
         self._xvfb_attached = False  # 是否附加到已有的 Xvfb 实例
         self._xvfb_attached_pid: Optional[int] = None  # 附加的 Xvfb PID
+        self._wm_name: Optional[str] = None  # [v1.23.45] 当前窗口管理器名称
         self._lock = asyncio.Lock()
 
         # noVNC web 文件路径（用于 aiohttp 静态文件服务）
@@ -477,6 +479,9 @@ class VNCManager:
             # 等待 Xvfb 就绪
             await asyncio.sleep(1)
 
+            # [v1.23.45] Step 2.5: 自动启动窗口管理器（解决黑屏问题）
+            await self._start_window_manager()
+
             # Step 3: 启动 x11vnc
             vnc_ok = await self._start_x11vnc()
             if not vnc_ok:
@@ -527,6 +532,12 @@ class VNCManager:
                 errors.extend(await self._kill_process(self._x11vnc_process, "x11vnc"))
                 self._x11vnc_process = None
 
+            # [v1.23.45] 停止窗口管理器
+            if self._wm_process:
+                errors.extend(await self._kill_process(self._wm_process, f"wm-{self._wm_name}"))
+                self._wm_process = None
+                self._wm_name = None
+
             # Xvfb: 只有自己启动的才杀，附加的不杀
             if self._xvfb_process:
                 errors.extend(await self._kill_process(self._xvfb_process, "Xvfb"))
@@ -729,6 +740,148 @@ class VNCManager:
             logger.error(f"Xvfb 启动异常: {e}")
             return False
 
+    async def _start_window_manager(self) -> None:
+        """[v1.23.45] 自动检测并启动窗口管理器，解决 VNC 黑屏问题。
+
+        优先级: 已运行的 WM > fluxbox > openbox > xfce4-session > icewm > jwm > 自动安装 fluxbox
+        """
+        import shutil
+
+        # 1. 检查是否已有窗口管理器在目标 DISPLAY 上运行
+        env = {**os.environ, "DISPLAY": self.display}
+        try:
+            result = subprocess.run(
+                ["pgrep", "-f", f"(fluxbox|openbox|xfce4-session|icewm|jwm|lxsession|gnome-session|startkde|mutter|kwin)"],
+                capture_output=True, text=True, timeout=5,
+            )
+            if result.returncode == 0 and result.stdout.strip():
+                pids = result.stdout.strip().split()
+                logger.info(f"检测到已有窗口管理器运行 (PIDs={pids[:3]})，跳过自动启动")
+                self._wm_name = "existing"
+                return
+        except Exception:
+            pass
+
+        # 2. 按优先级尝试启动
+        # 优先级: fluxbox > openbox > xfce4-session > icewm > jwm > twm
+        _wm_commands = [
+            ("fluxbox", ["fluxbox"]),
+            ("openbox", ["openbox", "--sm-disable"]),
+            ("xfce4-session", ["startxfce4"]),
+            ("icewm", ["icewm-session"]),
+            ("jwm", ["jwm"]),
+            ("twm", ["twm"]),  # twm 是 X11 自带的最小 WM
+        ]
+
+        wm_name = None
+        wm_cmd = None
+        for name, cmd in _wm_commands:
+            if shutil.which(cmd[0]):
+                wm_name = name
+                wm_cmd = cmd
+                break
+
+        if wm_name and wm_cmd:
+            try:
+                logger.info(f"启动窗口管理器: {wm_name} ({' '.join(wm_cmd)})")
+                self._wm_process = subprocess.Popen(
+                    wm_cmd,
+                    stdin=subprocess.DEVNULL,
+                    stdout=subprocess.DEVNULL,
+                    stderr=subprocess.DEVNULL,
+                    env=env,
+                    preexec_fn=os.setpgrp,
+                )
+                self._wm_name = wm_name
+                await asyncio.sleep(0.5)
+
+                if self._wm_process.poll() is None:
+                    logger.info(f"窗口管理器 {wm_name} 已启动 (PID={self._wm_process.pid})")
+                    # 设置一个简单的深灰色背景（避免纯黑）
+                    try:
+                        subprocess.run(
+                            ["xsetroot", "-solid", "#2d2d2d"],
+                            capture_output=True, timeout=5, env=env,
+                        )
+                    except Exception:
+                        pass
+                    return
+                else:
+                    logger.warning(f"窗口管理器 {wm_name} 启动后立即退出")
+            except Exception as e:
+                logger.warning(f"启动窗口管理器 {wm_name} 失败: {e}")
+
+        # 3. 没有可用的 WM → 尝试自动安装 fluxbox
+        logger.info("未找到已安装的窗口管理器，尝试自动安装 fluxbox...")
+        install_ok = await self._auto_install_wm()
+        if install_ok:
+            # 安装成功，重新尝试启动
+            for name, cmd in _wm_commands[:1]:  # 只尝试 fluxbox
+                if shutil.which(cmd[0]):
+                    try:
+                        logger.info(f"重新启动窗口管理器: {name}")
+                        self._wm_process = subprocess.Popen(
+                            cmd,
+                            stdin=subprocess.DEVNULL,
+                            stdout=subprocess.DEVNULL,
+                            stderr=subprocess.DEVNULL,
+                            env=env,
+                            preexec_fn=os.setpgrp,
+                        )
+                        self._wm_name = name
+                        await asyncio.sleep(0.5)
+                        if self._wm_process.poll() is None:
+                            logger.info(f"窗口管理器 {name} 已启动 (PID={self._wm_process.pid})")
+                            try:
+                                subprocess.run(
+                                    ["xsetroot", "-solid", "#2d2d2d"],
+                                    capture_output=True, timeout=5, env=env,
+                                )
+                            except Exception:
+                                pass
+                            return
+                    except Exception as e:
+                        logger.warning(f"重新启动 {name} 失败: {e}")
+                    break
+
+        logger.warning(
+            "未能启动任何窗口管理器，VNC 将显示黑屏。"
+            "请手动安装: sudo apt install -y fluxbox xterm"
+        )
+
+    async def _auto_install_wm(self) -> bool:
+        """[v1.23.45] 自动安装 fluxbox 窗口管理器。"""
+        _apt_cmd = ["apt-get", "install", "-y", "fluxbox", "xterm"]
+        try:
+            # 尝试直接执行（root 环境）
+            result = subprocess.run(
+                _apt_cmd,
+                capture_output=True, text=True, timeout=120,
+            )
+            if result.returncode == 0:
+                logger.info("fluxbox 安装成功")
+                return True
+            # 尝试 sudo
+            result = subprocess.run(
+                ["sudo"] + _apt_cmd,
+                capture_output=True, text=True, timeout=120,
+            )
+            if result.returncode == 0:
+                logger.info("fluxbox 安装成功 (sudo)")
+                return True
+            stderr = result.stderr[:300] if result.stderr else ""
+            logger.warning(f"fluxbox 自动安装失败: {stderr}")
+            return False
+        except FileNotFoundError:
+            logger.warning("未找到 apt-get，无法自动安装窗口管理器")
+            return False
+        except subprocess.TimeoutExpired:
+            logger.warning("fluxbox 安装超时 (120s)")
+            return False
+        except Exception as e:
+            logger.warning(f"fluxbox 安装异常: {e}")
+            return False
+
     async def _start_x11vnc(self) -> bool:
         """启动 x11vnc VNC 服务器"""
         try:

package/package.json

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

package/scripts/cli.py

@@ -153,6 +153,75 @@ async def _run():
         sys.exit(1)
 
 
+def _filter_unknown_args(args, allowed_prefixes=None):
+    """[v1.23.46] 通用参数过滤器 — 去掉不认识的系统命令参数。
+
+    LLM 经常把系统命令的参数（如 ls -la, grep -n）传给 myagent-ai 子命令。
+    此函数只保留: 位置参数（不以 - 开头） + allowed_prefixes 匹配的选项。
+
+    Args:
+        args: 原始参数列表
+        allowed_prefixes: 允许的选项前缀集合（如 {"-p", "--pattern", "-r", "--max"}）
+    Returns:
+        过滤后的参数列表
+    """
+    if allowed_prefixes is None:
+        allowed_prefixes = set()
+
+    # 常见系统命令参数（标志，不带值）
+    _sys_flags = {
+        "-l", "-a", "-h", "-L", "-d", "-F", "-f", "-i", "-s", "-R",
+        "-S", "-t", "-r", "-u", "-c", "-1", "-m", "-x", "-o", "-g",
+        "-G", "-A", "-n", "-w", "-p", "-q", "-v", "-e", "-E", "-z",
+        "-b", "-B", "-T", "-H", "-I", "-k", "-N", "-W",
+        # GNU long options
+        "--color", "--group-directories-first", "--hide", "--indicator-style",
+        "--quoting-style", "--show-control-chars", "--sort", "--time",
+        "--time-style", "--format", "--human-readable", "-lh", "-la", "-al",
+        "-lr", "-lt", "-ls", "-ld", "-li", "-shal", "-lah",
+    }
+    # 带值的系统参数
+    _sys_opts = {
+        "--sort", "--time", "--time-style", "--format", "--hide",
+        "--indicator-style", "--quoting-style", "--context", "--width",
+        "--tabs", "--block-size",
+    }
+
+    filtered = []
+    skip_next = False
+    for arg in args:
+        if skip_next:
+            skip_next = False
+            continue
+
+        # 以 - 开头的是选项参数
+        if arg.startswith("-"):
+            # 检查是否在允许列表中
+            matched = any(arg.startswith(prefix) for prefix in allowed_prefixes)
+            if matched:
+                filtered.append(arg)
+                # 如果参数不含 =，且不是标志模式，可能需要跳过下一个
+                if "=" not in arg and arg not in allowed_prefixes:
+                    # 检查是否有对应的 long option 带 =
+                    pass
+                continue
+
+            # 不在允许列表中，检查是否是系统参数
+            stripped = arg.lstrip("-").rstrip("=")
+            if arg in _sys_flags or stripped in _sys_flags:
+                continue  # 标志，跳过
+            if arg in _sys_opts or stripped in _sys_opts:
+                skip_next = True  # 带值选项，跳过下一个
+                continue
+            # 未知选项，跳过
+            continue
+        else:
+            # 位置参数，保留
+            filtered.append(arg)
+
+    return filtered if filtered else args
+
+
 # =============================================================================
 # 感知命令
 # =============================================================================
@@ -308,6 +377,8 @@ async def cmd_write(args):
 async def cmd_ls(args):
     """列出目录内容"""
     import argparse
+    # [v1.23.46] 过滤系统 ls 参数（-l, -a, -la 等）
+    args = _filter_unknown_args(args, allowed_prefixes={"-p", "--pattern", "-r", "--recursive", "--max"})
     p = argparse.ArgumentParser(prog="myagent-ai ls", description="列出目录内容")
     p.add_argument("path", help="目录路径")
     p.add_argument("-p", "--pattern", default="*", help="文件匹配模式 (如 *.py)")
@@ -340,47 +411,15 @@ async def cmd_rm(args):
 async def cmd_grep(args):
     """搜索文件内容"""
     import argparse
-    # [v1.23.42] 预过滤不支持的参数，防止 Agent 把系统 grep 参数传进来
-    # 区分标志（无参数）和选项（带参数）
-    _unsupported_flags = {"-n", "--line-number", "-l", "--files-with-matches",
-                          "-r", "-R", "--recursive", "-i", "--ignore-case",
-                          "-c", "--count", "-w", "--word-regexp", "-v",
-                          "--invert-match", "-E", "-F", "-P", "-m"}
-    _unsupported_opts = {"-e", "--regexp", "--include", "--exclude",
-                         "--after-context", "--before-context", "--context",
-                         "-A", "-B", "-C", "--max-count", "--color"}
-    _filtered = []
-    _skip_next = False
-    for i, a in enumerate(args):
-        if _skip_next:
-            _skip_next = False
-            continue
-        if a in _unsupported_flags:
-            # 标志参数，不跳过下一个
-            continue
-        if a in _unsupported_opts:
-            # 带参数选项，跳过下一个
-            _skip_next = True
-            continue
-        # 处理组合标志如 -rn、长选项 --name=Value
-        if any(a.startswith(k) for k in _unsupported_flags):
-            # -rn 或 -ni 等组合标志，不跳过下一个
-            continue
-        if any(a.startswith(k) for k in _unsupported_opts):
-            if "=" not in a:
-                _skip_next = True
-            continue
-        _filtered.append(a)
-    if not _filtered:
-        _filtered = args  # fallback
-
+    # [v1.23.46] 使用通用过滤器，过滤系统 grep 参数（-n, -i, -r 等）
+    args = _filter_unknown_args(args, allowed_prefixes={"-p", "--pattern", "--max", "--depth"})
     p = argparse.ArgumentParser(prog="myagent-ai grep", description="在目录中搜索文件内容")
     p.add_argument("query", help="搜索关键词")
     p.add_argument("path", help="搜索目录路径")
     p.add_argument("-p", "--pattern", default="*", help="文件匹配模式 (如 *.py)")
     p.add_argument("--max", type=int, default=50, help="最大结果数 (默认50)")
     p.add_argument("--depth", type=int, default=10, help="最大递归深度 (默认10)")
-    a = p.parse_args(_filtered)
+    a = p.parse_args(args)
 
     from skills.file_skill import FileSearchSkill
     skill = FileSearchSkill()