myagent-ai 1.18.1 → 1.18.3

package/core/vnc_manager.py

@@ -79,6 +79,8 @@ class VNCManager:
 
         # 状态标记
         self._running = False
+        self._xvfb_attached = False  # 是否附加到已有的 Xvfb 实例
+        self._xvfb_attached_pid: Optional[int] = None  # 附加的 Xvfb PID
         self._lock = asyncio.Lock()
 
         # noVNC web 文件路径（用于 aiohttp 静态文件服务）
@@ -88,10 +90,27 @@ class VNCManager:
     def is_running(self) -> bool:
         """VNC 服务是否正在运行"""
         if not self._running:
-            return False
+            # 即使内部标记为未运行，也检查系统上是否有 VNC 服务
+            # (myagent 重启后 _running 会重置为 False)
+            if self._detect_existing_services():
+                self._running = True
+                logger.info("检测到已有的 VNC 服务正在运行")
+            else:
+                return False
+
         # 检查各进程是否存活
+        # Xvfb: 如果是附加的实例，通过 PID 检查
+        if self._xvfb_attached:
+            if self._xvfb_attached_pid and not self._is_pid_alive(self._xvfb_attached_pid):
+                logger.warning("附加的 Xvfb 进程已退出")
+                self._running = False
+                return False
+        elif self._xvfb_process and self._xvfb_process.poll() is not None:
+            logger.warning(f"Xvfb 进程已退出 (exit code: {self._xvfb_process.returncode})")
+            self._running = False
+            return False
+
         for proc, name in [
-            (self._xvfb_process, "Xvfb"),
             (self._x11vnc_process, "x11vnc"),
             (self._websockify_process, "websockify"),
         ]:
@@ -101,6 +120,72 @@ class VNCManager:
                 return False
         return True
 
+    def _is_pid_alive(self, pid: int) -> bool:
+        """检查进程是否存活"""
+        try:
+            os.kill(pid, 0)  # 发送信号 0，不实际杀死进程
+            return True
+        except (OSError, ProcessLookupError):
+            return False
+
+    def _detect_existing_services(self) -> bool:
+        """检测系统上是否已有 VNC 相关服务在运行（用于 myagent 重启后恢复状态）"""
+        display_num = self.display.replace(":", "")
+        socket_path = f"/tmp/.X11-unix/X{display_num}"
+
+        # 检查 Xvfb socket 和进程
+        xvfb_ok = False
+        if os.path.exists(socket_path):
+            try:
+                result = subprocess.run(
+                    ["pgrep", "-f", f"Xvfb {self.display}"],
+                    capture_output=True, text=True, timeout=5,
+                )
+                if result.returncode == 0 and result.stdout.strip():
+                    xvfb_ok = True
+            except Exception:
+                pass
+
+        if not xvfb_ok:
+            return False
+
+        # 检查 x11vnc 是否在监听端口
+        x11vnc_ok = self._is_port_listening(self.x11vnc_port)
+        if not x11vnc_ok:
+            return False
+
+        # 检查 websockify 是否在监听端口
+        websockify_ok = self._is_port_listening(self.novnc_port)
+
+        if xvfb_ok and x11vnc_ok and websockify_ok:
+            # 恢复附加状态
+            self._xvfb_attached = True
+            try:
+                result = subprocess.run(
+                    ["pgrep", "-f", f"Xvfb {self.display}"],
+                    capture_output=True, text=True, timeout=5,
+                )
+                if result.returncode == 0:
+                    self._xvfb_attached_pid = int(result.stdout.strip().split()[0])
+            except Exception:
+                pass
+            return True
+
+        return False
+
+    @staticmethod
+    def _is_port_listening(port: int) -> bool:
+        """检查端口是否在监听"""
+        try:
+            import socket
+            s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+            s.settimeout(0.5)
+            s.connect(("127.0.0.1", port))
+            s.close()
+            return True
+        except (OSError, ConnectionRefusedError):
+            return False
+
     @property
     def display_env(self) -> Dict[str, str]:
         """返回 DISPLAY 环境变量字典，供子进程使用"""
@@ -109,29 +194,39 @@ class VNCManager:
     @property
     def status(self) -> Dict[str, Any]:
         """获取当前状态信息"""
-        xvfb_alive = self._xvfb_process is not None and self._xvfb_process.poll() is None
+        running = self.is_running
+
+        # Xvfb: 附加模式 vs 自启动模式
+        if self._xvfb_attached:
+            xvfb_alive = self._xvfb_attached_pid is not None and self._is_pid_alive(self._xvfb_attached_pid)
+            xvfb_pid = self._xvfb_attached_pid if xvfb_alive else None
+        else:
+            xvfb_alive = self._xvfb_process is not None and self._xvfb_process.poll() is None
+            xvfb_pid = self._xvfb_process.pid if xvfb_alive else None
+
         vnc_alive = self._x11vnc_process is not None and self._x11vnc_process.poll() is None
         ws_alive = self._websockify_process is not None and self._websockify_process.poll() is None
 
         return {
-            "running": self.is_running,
+            "running": running,
             "display": self.display,
             "resolution": self.resolution,
             "xvfb": {
-                "alive": xvfb_alive,
-                "pid": self._xvfb_process.pid if xvfb_alive else None,
+                "alive": xvfb_alive or running,  # 如果整体在运行，Xvfb 肯定是活的
+                "pid": xvfb_pid,
+                "attached": self._xvfb_attached,
             },
             "x11vnc": {
-                "alive": vnc_alive,
+                "alive": vnc_alive or running,
                 "port": self.x11vnc_port,
                 "pid": self._x11vnc_process.pid if vnc_alive else None,
             },
             "websockify": {
-                "alive": ws_alive,
+                "alive": ws_alive or running,
                 "port": self.novnc_port,
                 "pid": self._websockify_process.pid if ws_alive else None,
             },
-            "novnc_url": f"/vnc/vnc.html?autoconnect=true&resize=scale" if self.is_running else None,
+            "novnc_url": f"/vnc/vnc.html?autoconnect=true&resize=scale" if running else None,
         }
 
     def get_novnc_url(self, base_url: str = "") -> Optional[str]:
@@ -280,7 +375,7 @@ class VNCManager:
         """启动 VNC 远程桌面服务。
         
         启动顺序:
-          1. Xvfb (虚拟显示)
+          1. Xvfb (虚拟显示) — 如果已在运行则附加
           2. x11vnc (VNC 服务器)
           3. websockify (WebSocket 代理)
         
@@ -288,7 +383,9 @@ class VNCManager:
             {"success": bool, "message": str, "status": dict}
         """
         async with self._lock:
-            if self._running:
+            # 检查是否已在运行（包括检测系统上已有的服务）
+            if self._running or self._detect_existing_services():
+                self._running = True
                 return {
                     "success": True,
                     "message": "VNC 服务已在运行中",
@@ -300,31 +397,7 @@ class VNCManager:
             if not ok:
                 return {"success": False, "message": f"依赖检查失败: {dep_msg}"}
 
-            # Step 2: 检查显示号是否已被占用
-            display_num = self.display.replace(":", "")
-            lock_file = f"/tmp/.X{display_num}-lock"
-            if os.path.exists(lock_file):
-                # 检查是否有 Xvfb 进程在运行
-                try:
-                    result = subprocess.run(
-                        ["pgrep", "-f", f"Xvfb {self.display}"],
-                        capture_output=True, text=True, timeout=5,
-                    )
-                    if result.returncode == 0 and result.stdout.strip():
-                        logger.info(f"Xvfb {self.display} 已在运行，跳过启动")
-                    else:
-                        # 锁文件存在但进程不在，清理锁文件
-                        try:
-                            os.remove(lock_file)
-                            socket_file = f"/tmp/.X11-unix/X{display_num}"
-                            if os.path.exists(socket_file):
-                                os.remove(socket_file)
-                        except OSError:
-                            pass
-                except Exception:
-                    pass
-
-            # Step 3: 启动 Xvfb
+            # Step 2: 启动或附加 Xvfb
             xvfb_ok = await self._start_xvfb()
             if not xvfb_ok:
                 await self.stop()
@@ -333,7 +406,7 @@ class VNCManager:
             # 等待 Xvfb 就绪
             await asyncio.sleep(1)
 
-            # Step 4: 启动 x11vnc
+            # Step 3: 启动 x11vnc
             vnc_ok = await self._start_x11vnc()
             if not vnc_ok:
                 await self.stop()
@@ -342,13 +415,13 @@ class VNCManager:
             # 等待 x11vnc 就绪
             await asyncio.sleep(1)
 
-            # Step 5: 启动 websockify
+            # Step 4: 启动 websockify
             ws_ok = await self._start_websockify()
             if not ws_ok:
                 await self.stop()
                 return {"success": False, "message": "websockify 启动失败", "status": self.status}
 
-            # Step 6: 查找 noVNC web 文件
+            # Step 5: 查找 noVNC web 文件
             self._novnc_web_dir = self._find_novnc_dir()
             if self._novnc_web_dir:
                 logger.info(f"noVNC web 文件: {self._novnc_web_dir}")
@@ -383,20 +456,27 @@ class VNCManager:
                 errors.extend(await self._kill_process(self._x11vnc_process, "x11vnc"))
                 self._x11vnc_process = None
 
+            # Xvfb: 只有自己启动的才杀，附加的不杀
             if self._xvfb_process:
                 errors.extend(await self._kill_process(self._xvfb_process, "Xvfb"))
                 self._xvfb_process = None
-
-            # 清理锁文件和 socket
-            display_num = self.display.replace(":", "")
-            for f in [f"/tmp/.X{display_num}-lock", f"/tmp/.X11-unix/X{display_num}"]:
-                try:
-                    if os.path.exists(f):
-                        os.remove(f)
-                except OSError:
-                    pass
+            elif self._xvfb_attached:
+                logger.info(f"Xvfb {self.display} 是附加到已有实例，不停止 (PID={self._xvfb_attached_pid})")
+                self._xvfb_attached = False
+                self._xvfb_attached_pid = None
+
+            # 清理锁文件和 socket (只清理自己启动的)
+            if not self._xvfb_attached:
+                display_num = self.display.replace(":", "")
+                for f in [f"/tmp/.X{display_num}-lock", f"/tmp/.X11-unix/X{display_num}"]:
+                    try:
+                        if os.path.exists(f):
+                            os.remove(f)
+                    except OSError:
+                        pass
 
             self._running = False
+            self._xvfb_attached = False
 
             if errors:
                 return {"success": True, "message": f"VNC 已停止 (部分警告: {'; '.join(errors)})"}
@@ -489,8 +569,40 @@ class VNCManager:
     # ── 内部方法 ──────────────────────────────────────────
 
     async def _start_xvfb(self) -> bool:
-        """启动 Xvfb 虚拟显示服务器"""
+        """启动或附加到 Xvfb 虚拟显示服务器"""
         try:
+            display_num = self.display.replace(":", "")
+            socket_path = f"/tmp/.X11-unix/X{display_num}"
+
+            # 检查 Xvfb 是否已在运行
+            if os.path.exists(socket_path):
+                try:
+                    result = subprocess.run(
+                        ["pgrep", "-f", f"Xvfb {self.display}"],
+                        capture_output=True, text=True, timeout=5,
+                    )
+                    if result.returncode == 0 and result.stdout.strip():
+                        # Xvfb 已在运行，附加到它
+                        pid = int(result.stdout.strip().split()[0])
+                        self._xvfb_attached = True
+                        self._xvfb_attached_pid = pid
+                        logger.info(f"Xvfb {self.display} 已在运行 (PID={pid})，附加到现有实例")
+                        return True
+                    else:
+                        # 锁文件/socket 存在但进程不在，清理
+                        logger.info(f"Xvfb {self.display} socket 存在但进程不在，清理残留文件")
+                        lock_file = f"/tmp/.X{display_num}-lock"
+                        try:
+                            os.remove(lock_file)
+                        except OSError:
+                            pass
+                        try:
+                            os.remove(socket_path)
+                        except OSError:
+                            pass
+                except Exception as e:
+                    logger.warning(f"检查 Xvfb 状态异常: {e}")
+
             cmd = [
                 "Xvfb",
                 self.display,
@@ -529,8 +641,6 @@ class VNCManager:
                 return False
 
             # 验证 X socket 是否已创建
-            display_num = self.display.replace(":", "")
-            socket_path = f"/tmp/.X11-unix/X{display_num}"
             for _ in range(10):
                 if os.path.exists(socket_path):
                     break

package/package.json

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

package/web/api_server.py

@@ -4061,13 +4061,14 @@ window.toggleFullscreen = function() {{
         return chain
 
     def _reorder_model_chain_for_images(self, model_chain: list[dict], has_images: bool) -> list[dict]:
-        """[v1.16.14→18] 当消息包含图片时，将支持 vision 的模型优先排列
+        """[v1.16.14→18.2] 当消息包含图片时，将支持 vision 的模型优先排列
 
         优先从 model_chain 自带的 input_modes 读取（v1.16.18 改进），
         其次从 models_library 二次查找（兼容旧逻辑）。
 
         检查每个模型的 input_modes 字段，如果包含 "image"，则优先使用。
-        如果都没有 vision 能力，则保持原序（会触发 main_agent 的纯文本降级）。
+        如果 chain 中没有 vision 模型，自动从全局 models_library 查找 vision
+        兜底模型追加到 chain 末尾（v1.18.2 改进）。
         """
         if not has_images or not model_chain:
             return model_chain
@@ -4075,9 +4076,11 @@ window.toggleFullscreen = function() {{
         # 从 model_chain 自带的 input_modes 或 models_library 获取
         vision_models = []
         text_only_models = []
+        chain_ids = set()
         for mc in model_chain:
             mc_id = mc.get("id", "")
             model_name = mc.get("name", mc.get("model", "?"))
+            chain_ids.add(mc_id)
 
             # [v1.16.18] 优先使用 chain 自带的 input_modes
             input_modes = mc.get("input_modes", None)
@@ -4091,8 +4094,6 @@ window.toggleFullscreen = function() {{
                             input_modes = me.input_modes or ["text"]
                             break
 
-            logger.debug(f"模型 {model_name} (id={mc_id}) input_modes={input_modes}")
-            # [v1.17.1] 改为 info 级别，方便排查
             logger.info(f"[reorder] 模型 {model_name} (id={mc_id}) input_modes={input_modes}")
             if "image" in input_modes:
                 vision_models.append(mc)
@@ -4102,13 +4103,43 @@ window.toggleFullscreen = function() {{
         if vision_models:
             logger.info(f"消息含图片，优先使用 vision 模型: {[m.get('name', m.get('model')) for m in vision_models]}")
             return vision_models + text_only_models
-        else:
-            # [v1.16.18] 详细日志帮助排查问题
-            chain_info = []
-            for mc in model_chain:
-                chain_info.append(f"{mc.get('name', mc.get('model', '?'))}(id={mc.get('id','')}, input_modes={mc.get('input_modes','?')})")
-            logger.warning(f"消息含图片，但模型链中无 vision 模型，链详情: {chain_info}，将尝试当前主模型（失败后自动降级纯文本）")
-            return model_chain
+
+        # [v1.18.2] chain 中没有 vision 模型 → 从全局 models_library 自动找 vision 兜底
+        llm_defaults = self.core.config.llm
+        auto_vision = None
+        for me in self.core.config.models_library:
+            if me.id in chain_ids:
+                continue  # 跳过已在 chain 中的
+            modes = me.input_modes or ["text"]
+            if "image" in modes and me.enabled:
+                auto_vision = me
+                break
+
+        if auto_vision:
+            vision_mc = {
+                "id": auto_vision.id,
+                "name": auto_vision.name,
+                "provider": auto_vision.provider or llm_defaults.provider,
+                "api_type": getattr(auto_vision, 'api_type', '') or llm_defaults.api_type,
+                "model": auto_vision.model or auto_vision.id,
+                "base_url": auto_vision.base_url or llm_defaults.base_url,
+                "api_key": auto_vision.api_key or llm_defaults.api_key,
+                "temperature": auto_vision.temperature if auto_vision.temperature is not None else llm_defaults.temperature,
+                "max_tokens": auto_vision.max_tokens if auto_vision.max_tokens else llm_defaults.max_tokens,
+                "context_window": getattr(auto_vision, 'context_window', None) or llm_defaults.context_window,
+                "input_modes": list(auto_vision.input_modes or ["text"]),
+                "is_backup": True,
+                "_auto_vision": True,  # 标记：自动追加的 vision 兜底
+            }
+            logger.warning(f"消息含图片，agent 模型链无 vision 模型，自动追加全局 vision 兜底: {auto_vision.name} (id={auto_vision.id})")
+            return [vision_mc] + text_only_models
+
+        # 既没有 chain 内 vision，也没有全局兜底 → 保持原序，让 main_agent 降级纯文本
+        chain_info = []
+        for mc in model_chain:
+            chain_info.append(f"{mc.get('name', mc.get('model', '?'))}(id={mc.get('id','')}, modes={mc.get('input_modes','?')})")
+        logger.warning(f"消息含图片，但无可用 vision 模型，链详情: {chain_info}，将降级纯文本")
+        return model_chain
 
     async def _try_model_chain(self, model_chain: list[dict], message: str, session_id: str,
                                  agent_path: str = None, agent_system_prompt: str = None,
@@ -4135,6 +4166,7 @@ window.toggleFullscreen = function() {{
 
         for i, mc in enumerate(model_chain):
             is_backup = mc.get("is_backup", False)
+            is_auto_vision = mc.get("_auto_vision", False)
             model_label = f"{'备用' if is_backup else '主'}模型 {mc.get('name', mc.get('model', '?'))}"
             logger.info(f"尝试 {model_label} ({i+1}/{len(model_chain)}): provider={mc.get('provider')}, model={mc.get('model')}")
 
@@ -4208,6 +4240,10 @@ window.toggleFullscreen = function() {{
                     used_model_name = model_label
                     if is_backup:
                         logger.warning(f"🔄 主模型失败，成功切换到 {model_label}")
+                    # [v1.18.2] 自动 vision 兜底成功的提醒
+                    if is_auto_vision:
+                        _hint = f"💡 当前绑定的模型不支持图片，已自动切换到 {mc.get('name', mc.get('model', '?'))} 处理。\n\n"
+                        return _hint + response
                     return response
 
                 last_error = response
@@ -4265,6 +4301,8 @@ window.toggleFullscreen = function() {{
         """_try_model_chain_stream 的实际执行体（已在 _model_chain_lock 保护下）"""
         llm = self.core.llm
         full_text = ""
+        _auto_vision_switched = False  # [v1.18.2] 标记是否发生了 vision 自动切换
+        _auto_vision_model_name = ""
 
         for i, mc in enumerate(model_chain):
             orig = {
@@ -4288,6 +4326,11 @@ window.toggleFullscreen = function() {{
                             agent.context_builder.context_window = mc["context_window"]
                 llm._client = None
 
+                # [v1.18.2] 检测是否是自动追加的 vision 兜底模型
+                is_auto_vision = mc.get("_auto_vision", False)
+                if is_auto_vision:
+                    _auto_vision_model_name = mc.get("name", mc.get("model", "?"))
+
                 # Pass agent context through AgentContext instead of instance attrs
                 result = await self._stream_process_message(
                     message, session_id, stream_response,
@@ -4296,6 +4339,11 @@ window.toggleFullscreen = function() {{
                     user_images=user_images, user_files=user_files,
                 )
                 if result and not result.startswith("⚠️") and not result.startswith("❌"):
+                    # [v1.18.2] 如果是通过自动 vision 兜底成功的，在响应前追加提醒
+                    if is_auto_vision and user_images:
+                        _hint = f"💡 当前绑定的模型不支持图片，已自动切换到 {_auto_vision_model_name} 处理。\n\n"
+                        logger.info(f"自动 vision 兜底成功: {_auto_vision_model_name}")
+                        return _hint + result
                     return result
                 # 如果返回了错误消息，保存它以便最后返回
                 if result:
@@ -4314,6 +4362,23 @@ window.toggleFullscreen = function() {{
                         if hasattr(agent, 'context_builder') and agent.context_builder:
                             agent.context_builder.context_window = orig["context_window"]
 
+        # [v1.18.2] 所有模型都失败，且包含图片，给出明确的配置提示
+        if user_images and full_text and "不支持图片" in full_text:
+            # 查找可用的 vision 模型名称
+            vision_names = []
+            for me in self.core.config.models_library:
+                modes = me.input_modes or ["text"]
+                if "image" in modes and me.enabled:
+                    vision_names.append(me.name or me.id)
+            if vision_names:
+                return (f"⚠️ 当前绑定的模型不支持图片识别，自动切换也未找到可用的图片模型。\n\n"
+                        f"📋 模型库中支持图片的模型: {', '.join(vision_names[:5])}\n\n"
+                        f"请在 agent 设置中将其中一个绑定为模型或备用模型，以便识别图片。")
+            else:
+                return (f"⚠️ 当前绑定的模型不支持图片识别，且模型库中没有任何支持图片的模型。\n\n"
+                        f"请在 models_library 中添加一个支持 vision 的模型（input_modes 包含 \"image\"），"
+                        f"然后绑定到当前 agent。")
+
         return full_text
 
     async def _stream_text_chunked(self, text: str, write_sse, chunk_size: int = 4, delay: float = 0.015):

package/web/ui/chat/chat_main.js

@@ -942,8 +942,18 @@ function updateVNCButton() {
 }
 
 async function toggleVNC() {
+  // 先刷新一次状态（避免因轮询间隔导致状态过期）
+  try {
+    var latest = await api('/api/vnc/status');
+    if (latest && latest.running) {
+      vncStatus = latest;
+      updateVNCButton();
+      openVNCWindow();
+      return;
+    }
+  } catch (e) {}
+
   if (vncStatus.running) {
-    // VNC 正在运行，打开远程桌面窗口
     openVNCWindow();
     return;
   }
@@ -957,12 +967,18 @@ async function toggleVNC() {
   try {
     var result = await api('/api/vnc/start', { method: 'POST' });
     if (result.success) {
-      toast('远程桌面已启动', 'success');
       await refreshVNCStatus();
-      // 延迟打开远程桌面窗口（等待服务完全就绪）
-      setTimeout(function() {
+      // 如果是"已在运行"（附加到已有实例），立刻打开窗口
+      if (result.message && result.message.indexOf('已在运行') > -1) {
+        toast('远程桌面已连接', 'success');
         openVNCWindow();
-      }, 2000);
+      } else {
+        toast('远程桌面已启动', 'success');
+        // 新启动的需要等服务完全就绪
+        setTimeout(function() {
+          openVNCWindow();
+        }, 2000);
+      }
     } else {
       toast('启动失败: ' + (result.message || '未知错误'), 'error');
     }