jarvis-ai-assistant 0.1.222__py3-none-any.whl → 0.7.0__py3-none-any.whl

jarvis/jarvis_tools/virtual_tty.py

@@ -1,11 +1,20 @@
 # -*- coding: utf-8 -*-
-import fcntl
 import os
-import pty
-import select
-import signal
+import sys
 import time
-from typing import Any, Dict
+from typing import Any, Dict, TYPE_CHECKING
+from jarvis.jarvis_utils.output import OutputType, PrettyOutput
+
+# 为了类型检查，总是导入这些模块
+if TYPE_CHECKING:
+    pass
+
+# 平台相关的导入
+if sys.platform != "win32":
+    pass
+else:
+    # Windows平台的导入
+    pass
 
 
 class VirtualTTYTool:
@@ -14,6 +23,7 @@ class VirtualTTYTool:
         "控制虚拟终端执行各种操作，如启动终端、输入命令、获取输出等。"
         + "与execute_script不同，此工具会创建一个持久的虚拟终端会话，可以连续执行多个命令，并保持终端状态。"
         + "适用于需要交互式操作的场景，如运行需要用户输入的交互式程序（如：ssh连接、sftp传输、gdb/dlv调试等）。"
+        + "注意：Windows平台功能有限，某些Unix特有功能可能不可用。"
     )
     parameters = {
         "type": "object",
@@ -76,11 +86,21 @@ class VirtualTTYTool:
 
         # 如果指定的tty_id不存在，为其创建一个新的tty_data
         if tty_id not in agent.tty_sessions:
-            agent.tty_sessions[tty_id] = {
-                "master_fd": None,
-                "pid": None,
-                "shell": "/bin/bash",
-            }
+            if sys.platform == "win32":
+                import queue as _queue  # pylint: disable=import-outside-toplevel
+
+                agent.tty_sessions[tty_id] = {
+                    "process": None,
+                    "output_queue": _queue.Queue(),
+                    "output_thread": None,
+                    "shell": "cmd.exe",
+                }
+            else:
+                agent.tty_sessions[tty_id] = {
+                    "master_fd": None,
+                    "pid": None,
+                    "shell": "/bin/bash",
+                }
 
         action = args.get("action", "").strip().lower()
 
@@ -96,62 +116,62 @@ class VirtualTTYTool:
         try:
             if action == "launch":
                 if args.get("keys", "") != "":
-                    print(f"🚫 启动虚拟终端时，不能同时指定keys参数")
+                    PrettyOutput.print(
+                        "启动虚拟终端时，不能同时指定 keys 参数", OutputType.ERROR
+                    )
                     return {
                         "success": False,
                         "stdout": "",
                         "stderr": "启动虚拟终端时，不能同时指定keys参数",
                     }
-                print(f"🚀 正在启动虚拟终端 [{tty_id}]...")
+
                 result = self._launch_tty(agent, tty_id)
-                if result["success"]:
-                    print(f"✅ 启动虚拟终端 [{tty_id}] 成功")
-                else:
-                    print(f"❌ 启动虚拟终端 [{tty_id}] 失败")
+                if not result["success"]:
+                    PrettyOutput.print(
+                        f"启动虚拟终端 [{tty_id}] 失败", OutputType.ERROR
+                    )
                 return result
             elif action == "send_keys":
                 keys = args.get("keys", "").strip()
                 add_enter = args.get("add_enter", True)
                 timeout = args.get("timeout", 5.0)  # 默认5秒超时
-                print(f"⌨️ 正在向终端 [{tty_id}] 发送按键序列: {keys}...")
+
                 result = self._input_command(agent, tty_id, keys, timeout, add_enter)
-                if result["success"]:
-                    print(f"✅ 发送按键序列到终端 [{tty_id}] 成功")
-                else:
-                    print(f"❌ 发送按键序列到终端 [{tty_id}] 失败")
+                if not result["success"]:
+                    PrettyOutput.print(
+                        f"发送按键序列到终端 [{tty_id}] 失败", OutputType.ERROR
+                    )
                 return result
             elif action == "output":
                 timeout = args.get("timeout", 5.0)  # 默认5秒超时
-                print(f"📥 正在获取终端 [{tty_id}] 输出...")
+
                 result = self._get_output(agent, tty_id, timeout)
-                if result["success"]:
-                    print(f"✅ 获取终端 [{tty_id}] 输出成功")
-                else:
-                    print(f"❌ 获取终端 [{tty_id}] 输出失败")
+                if not result["success"]:
+                    PrettyOutput.print(
+                        f"获取终端 [{tty_id}] 输出失败", OutputType.ERROR
+                    )
                 return result
             elif action == "close":
-                print(f"🔒 正在关闭虚拟终端 [{tty_id}]...")
+
                 result = self._close_tty(agent, tty_id)
-                if result["success"]:
-                    print(f"✅ 关闭虚拟终端 [{tty_id}] 成功")
-                else:
-                    print(f"❌ 关闭虚拟终端 [{tty_id}] 失败")
+                if not result["success"]:
+                    PrettyOutput.print(
+                        f"关闭虚拟终端 [{tty_id}] 失败", OutputType.ERROR
+                    )
                 return result
             elif action == "get_screen":
-                print(f"🖥️ 正在获取终端 [{tty_id}] 屏幕内容...")
+
                 result = self._get_screen(agent, tty_id)
-                if result["success"]:
-                    print(f"✅ 获取终端 [{tty_id}] 屏幕内容成功")
-                else:
-                    print(f"❌ 获取终端 [{tty_id}] 屏幕内容失败")
+                if not result["success"]:
+                    PrettyOutput.print(
+                        f"获取终端 [{tty_id}] 屏幕内容失败", OutputType.ERROR
+                    )
                 return result
             elif action == "list":
-                print("📋 正在获取所有虚拟终端列表...")
+
                 result = self._list_ttys(agent)
-                if result["success"]:
-                    print("✅ 获取虚拟终端列表成功")
-                else:
-                    print("❌ 获取虚拟终端列表失败")
+                if not result["success"]:
+                    PrettyOutput.print("获取虚拟终端列表失败", OutputType.ERROR)
                 return result
             return {"success": False, "stdout": "", "stderr": "不支持的操作"}
 
@@ -164,13 +184,25 @@ class VirtualTTYTool:
 
     def _launch_tty(self, agent: Any, tty_id: str) -> Dict[str, Any]:
         """启动虚拟终端"""
+        if sys.platform == "win32":
+            return self._launch_tty_windows(agent, tty_id)
+        else:
+            return self._launch_tty_unix(agent, tty_id)
+
+    def _launch_tty_unix(self, agent: Any, tty_id: str) -> Dict[str, Any]:
+        """Unix/Linux平台启动虚拟终端"""
         try:
             # 如果该ID的终端已经启动，先关闭它
             if agent.tty_sessions[tty_id]["master_fd"] is not None:
                 self._close_tty(agent, tty_id)
 
+            # 在Unix平台上导入需要的模块
+            import pty as _pty  # pylint: disable=import-outside-toplevel
+            import fcntl as _fcntl  # pylint: disable=import-outside-toplevel
+            import select as _select  # pylint: disable=import-outside-toplevel
+
             # 创建伪终端
-            pid, master_fd = pty.fork()
+            pid, master_fd = _pty.fork()
 
             if pid == 0:  # 子进程
                 # 执行shell
@@ -180,7 +212,7 @@ class VirtualTTYTool:
                 )
             else:  # 父进程
                 # 设置非阻塞模式
-                fcntl.fcntl(master_fd, fcntl.F_SETFL, os.O_NONBLOCK)
+                _fcntl.fcntl(master_fd, _fcntl.F_SETFL, os.O_NONBLOCK)
 
                 # 保存终端状态
                 agent.tty_sessions[tty_id]["master_fd"] = master_fd
@@ -191,7 +223,7 @@ class VirtualTTYTool:
                 start_time = time.time()
                 while time.time() - start_time < 2.0:  # 最多等待2秒
                     try:
-                        r, _, _ = select.select([master_fd], [], [], 0.1)
+                        r, _, _ = _select.select([master_fd], [], [], 0.1)
                         if r:
                             data = os.read(master_fd, 1024)
                             if data:
@@ -199,9 +231,6 @@ class VirtualTTYTool:
                     except BlockingIOError:
                         continue
 
-                if output:
-                    print(f"📤 终端 [{tty_id}]: {output}")
-
                 return {"success": True, "stdout": output, "stderr": ""}
 
         except Exception as e:
@@ -211,6 +240,71 @@ class VirtualTTYTool:
                 "stderr": f"启动虚拟终端 [{tty_id}] 失败: {str(e)}",
             }
 
+    def _launch_tty_windows(self, agent: Any, tty_id: str) -> Dict[str, Any]:
+        """Windows平台启动虚拟终端"""
+        try:
+            # 如果该ID的终端已经启动，先关闭它
+            if agent.tty_sessions[tty_id]["process"] is not None:
+                self._close_tty(agent, tty_id)
+
+            # 在Windows平台上导入需要的模块
+            import subprocess as _subprocess  # pylint: disable=import-outside-toplevel
+            import threading as _threading  # pylint: disable=import-outside-toplevel
+            import queue as _queue  # pylint: disable=import-outside-toplevel
+
+            # 创建子进程
+            process = _subprocess.Popen(
+                agent.tty_sessions[tty_id]["shell"],
+                stdin=_subprocess.PIPE,
+                stdout=_subprocess.PIPE,
+                stderr=_subprocess.STDOUT,
+                shell=True,
+                text=True,
+                bufsize=0,
+                encoding="utf-8",
+                errors="replace",
+            )
+
+            # 保存进程对象
+            agent.tty_sessions[tty_id]["process"] = process
+
+            # 创建输出读取线程
+            def read_output():
+                while True:
+                    if process is None or process.poll() is not None:
+                        break
+                    try:
+                        if process.stdout is None:
+                            break
+                        line = process.stdout.readline()
+                        if line:
+                            agent.tty_sessions[tty_id]["output_queue"].put(line)
+                    except Exception:
+                        break
+
+            output_thread = _threading.Thread(target=read_output, daemon=True)
+            output_thread.start()
+            agent.tty_sessions[tty_id]["output_thread"] = output_thread
+
+            # 读取初始输出
+            output = ""
+            start_time = time.time()
+            while time.time() - start_time < 2.0:  # 最多等待2秒
+                try:
+                    line = agent.tty_sessions[tty_id]["output_queue"].get(timeout=0.1)
+                    output += line
+                except _queue.Empty:
+                    continue
+
+            return {"success": True, "stdout": output, "stderr": ""}
+
+        except Exception as e:
+            return {
+                "success": False,
+                "stdout": "",
+                "stderr": f"启动虚拟终端 [{tty_id}] 失败: {str(e)}",
+            }
+
     def _input_command(
         self,
         agent: Any,
@@ -225,6 +319,22 @@ class VirtualTTYTool:
             command: 要输入的单行命令
             add_enter: 是否在命令末尾添加回车符
         """
+        if sys.platform == "win32":
+            return self._input_command_windows(
+                agent, tty_id, command, timeout, add_enter
+            )
+        else:
+            return self._input_command_unix(agent, tty_id, command, timeout, add_enter)
+
+    def _input_command_unix(
+        self,
+        agent: Any,
+        tty_id: str,
+        command: str,
+        timeout: float,
+        add_enter: bool = True,
+    ) -> Dict[str, Any]:
+        """Unix/Linux平台输入命令"""
         if agent.tty_sessions[tty_id]["master_fd"] is None:
             return {
                 "success": False,
@@ -251,7 +361,9 @@ class VirtualTTYTool:
             while time.time() - start_time < timeout:
                 try:
                     # 使用select等待数据可读
-                    r, _, _ = select.select(
+                    import select as _select  # pylint: disable=import-outside-toplevel
+
+                    r, _, _ = _select.select(
                         [agent.tty_sessions[tty_id]["master_fd"]], [], [], 0.1
                     )
                     if r:
@@ -260,7 +372,54 @@ class VirtualTTYTool:
                             output += data.decode()
                 except BlockingIOError:
                     continue
-            print(f"📤 终端 [{tty_id}]: {output}")
+            return {"success": True, "stdout": output, "stderr": ""}
+
+        except Exception as e:
+            return {
+                "success": False,
+                "stdout": "",
+                "stderr": f"在终端 [{tty_id}] 执行命令失败: {str(e)}",
+            }
+
+    def _input_command_windows(
+        self,
+        agent: Any,
+        tty_id: str,
+        command: str,
+        timeout: float,
+        add_enter: bool = True,
+    ) -> Dict[str, Any]:
+        """Windows平台输入命令"""
+        if agent.tty_sessions[tty_id]["process"] is None:
+            return {
+                "success": False,
+                "stdout": "",
+                "stderr": f"虚拟终端 [{tty_id}] 未启动",
+            }
+
+        # 严格检查并拒绝多行输入
+        if "\n" in command:
+            return {"success": False, "stdout": "", "stderr": "错误：禁止多行输入"}
+
+        try:
+            # 根据add_enter参数决定是否添加回车符
+            if add_enter:
+                command = command + "\n"
+
+            # 发送命令
+            agent.tty_sessions[tty_id]["process"].stdin.write(command)
+            agent.tty_sessions[tty_id]["process"].stdin.flush()
+
+            # 等待输出
+            output = ""
+            start_time = time.time()
+            while time.time() - start_time < timeout:
+                try:
+                    line = agent.tty_sessions[tty_id]["output_queue"].get(timeout=0.1)
+                    output += line
+                except Exception:  # queue.Empty
+                    continue
+
             return {"success": True, "stdout": output, "stderr": ""}
 
         except Exception as e:
@@ -274,6 +433,15 @@ class VirtualTTYTool:
         self, agent: Any, tty_id: str, timeout: float = 5.0
     ) -> Dict[str, Any]:
         """获取终端输出"""
+        if sys.platform == "win32":
+            return self._get_output_windows(agent, tty_id, timeout)
+        else:
+            return self._get_output_unix(agent, tty_id, timeout)
+
+    def _get_output_unix(
+        self, agent: Any, tty_id: str, timeout: float = 5.0
+    ) -> Dict[str, Any]:
+        """Unix/Linux平台获取输出"""
         if agent.tty_sessions[tty_id]["master_fd"] is None:
             return {
                 "success": False,
@@ -287,7 +455,9 @@ class VirtualTTYTool:
 
             while time.time() - start_time < timeout:
                 # 使用select等待数据可读
-                r, _, _ = select.select(
+                import select as _select  # pylint: disable=import-outside-toplevel
+
+                r, _, _ = _select.select(
                     [agent.tty_sessions[tty_id]["master_fd"]], [], [], 0.1
                 )
                 if r:
@@ -302,7 +472,36 @@ class VirtualTTYTool:
                                 break
                         except BlockingIOError:
                             break
-            print(f"📤 终端 [{tty_id}]: {output}")
+            return {"success": True, "stdout": output, "stderr": ""}
+
+        except Exception as e:
+            return {
+                "success": False,
+                "stdout": "",
+                "stderr": f"获取终端 [{tty_id}] 输出失败: {str(e)}",
+            }
+
+    def _get_output_windows(
+        self, agent: Any, tty_id: str, timeout: float = 5.0
+    ) -> Dict[str, Any]:
+        """Windows平台获取输出"""
+        if agent.tty_sessions[tty_id]["process"] is None:
+            return {
+                "success": False,
+                "stdout": "",
+                "stderr": f"虚拟终端 [{tty_id}] 未启动",
+            }
+
+        try:
+            output = ""
+            start_time = time.time()
+
+            while time.time() - start_time < timeout:
+                try:
+                    line = agent.tty_sessions[tty_id]["output_queue"].get(timeout=0.1)
+                    output += line
+                except Exception:  # queue.Empty
+                    continue
 
             return {"success": True, "stdout": output, "stderr": ""}
 
@@ -315,6 +514,13 @@ class VirtualTTYTool:
 
     def _close_tty(self, agent: Any, tty_id: str) -> Dict[str, Any]:
         """关闭虚拟终端"""
+        if sys.platform == "win32":
+            return self._close_tty_windows(agent, tty_id)
+        else:
+            return self._close_tty_unix(agent, tty_id)
+
+    def _close_tty_unix(self, agent: Any, tty_id: str) -> Dict[str, Any]:
+        """Unix/Linux平台关闭终端"""
         if agent.tty_sessions[tty_id]["master_fd"] is None:
             return {
                 "success": True,
@@ -328,7 +534,9 @@ class VirtualTTYTool:
 
             # 终止子进程
             if agent.tty_sessions[tty_id]["pid"]:
-                os.kill(agent.tty_sessions[tty_id]["pid"], signal.SIGTERM)
+                import signal as _signal  # pylint: disable=import-outside-toplevel
+
+                os.kill(agent.tty_sessions[tty_id]["pid"], _signal.SIGTERM)
 
             # 重置终端数据
             agent.tty_sessions[tty_id] = {
@@ -350,8 +558,53 @@ class VirtualTTYTool:
                 "stderr": f"关闭虚拟终端 [{tty_id}] 失败: {str(e)}",
             }
 
+    def _close_tty_windows(self, agent: Any, tty_id: str) -> Dict[str, Any]:
+        """Windows平台关闭终端"""
+        if agent.tty_sessions[tty_id]["process"] is None:
+            return {
+                "success": True,
+                "stdout": f"没有正在运行的虚拟终端 [{tty_id}]",
+                "stderr": "",
+            }
+
+        try:
+            # 终止进程
+            agent.tty_sessions[tty_id]["process"].terminate()
+            agent.tty_sessions[tty_id]["process"].wait()
+
+            # 重置终端数据
+            import queue as _queue  # pylint: disable=import-outside-toplevel
+
+            agent.tty_sessions[tty_id] = {
+                "process": None,
+                "output_queue": _queue.Queue(),
+                "output_thread": None,
+                "shell": "cmd.exe",
+            }
+
+            return {
+                "success": True,
+                "stdout": f"虚拟终端 [{tty_id}] 已关闭",
+                "stderr": "",
+            }
+
+        except Exception as e:
+            return {
+                "success": False,
+                "stdout": "",
+                "stderr": f"关闭虚拟终端 [{tty_id}] 失败: {str(e)}",
+            }
+
     def _get_screen(self, agent: Any, tty_id: str) -> Dict[str, Any]:
         """获取当前终端屏幕内容"""
+        if sys.platform == "win32":
+            # Windows平台暂不支持获取屏幕内容
+            return {
+                "success": False,
+                "stdout": "",
+                "stderr": "Windows平台暂不支持获取屏幕内容功能",
+            }
+
         if agent.tty_sessions[tty_id]["master_fd"] is None:
             return {
                 "success": False,
@@ -371,7 +624,9 @@ class VirtualTTYTool:
             start_time = time.time()
             while time.time() - start_time < 2.0:  # 最多等待2秒
                 try:
-                    r, _, _ = select.select(
+                    import select as _select  # pylint: disable=import-outside-toplevel
+
+                    r, _, _ = _select.select(
                         [agent.tty_sessions[tty_id]["master_fd"]], [], [], 0.1
                     )
                     if r:
@@ -404,15 +659,28 @@ class VirtualTTYTool:
             active_ttys = []
 
             for tty_id, tty_data in agent.tty_sessions.items():
-                status = "活动" if tty_data["master_fd"] is not None else "关闭"
-                active_ttys.append(
-                    {
-                        "id": tty_id,
-                        "status": status,
-                        "pid": tty_data["pid"] if tty_data["pid"] else None,
-                        "shell": tty_data["shell"],
-                    }
-                )
+                if sys.platform == "win32":
+                    status = "活动" if tty_data["process"] is not None else "关闭"
+                    active_ttys.append(
+                        {
+                            "id": tty_id,
+                            "status": status,
+                            "pid": (
+                                tty_data["process"].pid if tty_data["process"] else None
+                            ),
+                            "shell": tty_data["shell"],
+                        }
+                    )
+                else:
+                    status = "活动" if tty_data["master_fd"] is not None else "关闭"
+                    active_ttys.append(
+                        {
+                            "id": tty_id,
+                            "status": status,
+                            "pid": tty_data["pid"] if tty_data["pid"] else None,
+                            "shell": tty_data["shell"],
+                        }
+                    )
 
             # 格式化输出
             output = "虚拟终端列表:\n"

jarvis/jarvis_utils/builtin_replace_map.py

@@ -29,28 +29,27 @@ arguments:
 """,
         "description": "网页搜索",
     },
-    
     "FindRelatedFiles": {
         "append": False,
-        "template": f"""
+        "template": """
 请使用工具在当前目录下查找与以下功能相关的文件：
 """,
     },
     "Dev": {
         "append": False,
-        "template": f"""
+        "template": """
 请调用create_code_agent开发以下需求：
 """,
     },
     "Fix": {
         "append": False,
-        "template": f"""
+        "template": """
 请修复以下问题：
 """,
     },
     "Check": {
         "append": True,
-        "template": f"""
+        "template": """
 请使用静态检查工具检查当前代码，必须严格遵守工具调用格式。
 
 检查要求：

jarvis/jarvis_utils/clipboard.py

@@ -0,0 +1,90 @@
+# -*- coding: utf-8 -*-
+import platform
+import subprocess
+
+from jarvis.jarvis_utils.output import OutputType, PrettyOutput
+
+
+def copy_to_clipboard(text: str) -> None:
+    """将文本复制到剪贴板，支持Windows、macOS和Linux
+
+    参数:
+        text: 要复制的文本
+    """
+    PrettyOutput.print("--- 剪贴板内容开始 ---", OutputType.INFO)
+    print(text)
+    PrettyOutput.print("--- 剪贴板内容结束 ---", OutputType.INFO)
+
+    system = platform.system()
+
+    # Windows系统
+    if system == "Windows":
+        try:
+            # 使用Windows的clip命令
+            process = subprocess.Popen(
+                ["clip"],
+                stdin=subprocess.PIPE,
+                stdout=subprocess.DEVNULL,
+                stderr=subprocess.DEVNULL,
+                shell=True,
+            )
+            if process.stdin:
+                process.stdin.write(text.encode("utf-8"))
+                process.stdin.close()
+            return
+        except Exception as e:
+            PrettyOutput.print(f"使用Windows clip命令时出错: {e}", OutputType.WARNING)
+
+    # macOS系统
+    elif system == "Darwin":
+        try:
+            process = subprocess.Popen(
+                ["pbcopy"],
+                stdin=subprocess.PIPE,
+                stdout=subprocess.DEVNULL,
+                stderr=subprocess.DEVNULL,
+            )
+            if process.stdin:
+                process.stdin.write(text.encode("utf-8"))
+                process.stdin.close()
+            return
+        except Exception as e:
+            PrettyOutput.print(f"使用macOS pbcopy命令时出错: {e}", OutputType.WARNING)
+
+    # Linux系统
+    else:
+        # 尝试使用 xsel
+        try:
+            process = subprocess.Popen(
+                ["xsel", "-b", "-i"],
+                stdin=subprocess.PIPE,
+                stdout=subprocess.DEVNULL,
+                stderr=subprocess.DEVNULL,
+            )
+            if process.stdin:
+                process.stdin.write(text.encode("utf-8"))
+                process.stdin.close()
+            return
+        except FileNotFoundError:
+            pass  # xsel 未安装，继续尝试下一个
+        except Exception as e:
+            PrettyOutput.print(f"使用xsel时出错: {e}", OutputType.WARNING)
+
+        # 尝试使用 xclip
+        try:
+            process = subprocess.Popen(
+                ["xclip", "-selection", "clipboard"],
+                stdin=subprocess.PIPE,
+                stdout=subprocess.DEVNULL,
+                stderr=subprocess.DEVNULL,
+            )
+            if process.stdin:
+                process.stdin.write(text.encode("utf-8"))
+                process.stdin.close()
+            return
+        except FileNotFoundError:
+            PrettyOutput.print(
+                "xsel 和 xclip 均未安装, 无法复制到剪贴板", OutputType.WARNING
+            )
+        except Exception as e:
+            PrettyOutput.print(f"使用xclip时出错: {e}", OutputType.WARNING)