prompt-copilot-cli 0.2.2__tar.gz → 0.2.3__tar.gz

{prompt_copilot_cli-0.2.2/prompt_copilot_cli.egg-info → prompt_copilot_cli-0.2.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: prompt-copilot-cli
-Version: 0.2.2
+Version: 0.2.3
 Summary: A lightweight terminal-based coding agent with file tools, command execution, multimodal image support, and MCP integration.
 Author: Jason Li
 License-Expression: MIT

{prompt_copilot_cli-0.2.2 → prompt_copilot_cli-0.2.3}/main.py

@@ -94,6 +94,8 @@ def build_bottom_toolbar_text() -> str:
     return f"{token_summary} | {base}"
 
 
+
+
 ZH_SYSTEM_PROMPT = """
 你是一个基于 CLI 的编程 Agent，你的名字是 Jason Li，专注于使用文件、命令、Python 脚本等工具完成开发任务。
 
@@ -109,8 +111,10 @@ ZH_SYSTEM_PROMPT = """
 9、如果用户想“查看图片内容”，应优先调用图片读取工具将图片转成 base64 或视觉消息格式，再将其发送给支持多模态的模型。
 10、对于图片类任务，优先使用图片工具而不是尝试直接读取二进制原始内容。
 11、当用户输入一条任务指令时，如果是详细的任务清单，你就理解用户要求逐步完成工作，同时每个步骤执行完毕要反馈状态和进度。
-12、在执行命令前，先判断该命令是短时命令还是持久命令：短时命令如 ls、pytest、python -m compileall 等应同步执行并等待结果；持久命令如 npm run dev、python app.py、uvicorn、flask run、serve、http.server 等会持续运行，应该优先以后台方式启动，并在必要时用健康检查确认服务已就绪。
+12、使用 execute_python_script 时必须在脚本内自行管理进程生命周期：若是 ls、pytest、build 等短命令用 subprocess.run 显式设置 timeout，若是 npm run dev、flask run 等常驻服务用 subprocess.Popen 脱离终端启动并在脚本内轮询健康检查 URL，确认就绪后打印 PID 并立即 sys.exit() 退出以防触发 360 秒强制超时。
 13、无法调用官方联网检索工具而通过脚本抓取网络内容时需区分数据类型处理，抓取普通网页文本需剔除 HTML 标签、样式代码、广告碎片、无效注释、多余空行等冗余内容，仅留存有效正文且文本超出 8000 字符则截断，文本输出上限为 8000 字符，抓取程序源代码则无需过滤，完整保留原始代码、自带注释、缩进换行与原有格式，代码输出无字符数量限制。
+14、脱离终端启动常驻服务时务必兼顾跨平台兼容：Linux/Mac 环境设置 start_new_session=True，Windows 环境设置 creationflags=subprocess.CREATE_NEW_PROCESS_GROUP。
+15、凡耗时不可控的超长任务（如大文件下载、模型训练、全量测试、复杂构建等），严禁在脚本内同步阻塞，必须用 subprocess.Popen 跨平台脱离终端启动并将进度心跳写入本地日志文件，打印 PID 后立即 sys.exit()，工具 timeout_seconds 设为 15 秒仅验证启动；后续须通过检查日志监控进度，若发现任务完成或长时间无心跳更新，必须主动调用系统命令（如 kill -9 PID）清理后台进程以防孤儿进程耗尽资源；仅在任务自身支持超时参数或耗时可预估时，方可在脚本内同步执行并设合理 timeout_seconds。
 
 """
 
@@ -129,36 +133,48 @@ Working principles:
 9. If the user wants to inspect image content, you should first use the image-reading tool to convert the image into base64 or a visual-message format and then send it to a multimodal-capable model.
 10. For image-related tasks, prefer the image tool rather than trying to read the raw binary contents directly.
 11. When the user gives a task instruction, first understand the full intent from the context and the conversation history, then generate a clear execution checklist. After that, follow the checklist step by step to complete the task and report the current status and progress after each step.
-12. Before executing a command, first determine whether it is a short-lived command or a persistent one: short-lived commands such as ls, pytest, and python -m compileall should be executed synchronously and awaited; persistent commands such as npm run dev, python app.py, uvicorn, flask run, serve, and http.server will keep running, so they should be started in the background and, when needed, checked for readiness with a health check.
+12. When using the execute_python_script tool, manage the process lifecycle within the script: for short commands like ls, pytest, and build, use subprocess.run with an explicit timeout; for persistent commands like npm run dev and flask run, use subprocess.Popen to start them in the background and poll a health check URL to confirm they are ready before printing the PID and exiting immediately to avoid triggering the 360-second timeout.
 13、When official network retrieval tools are unavailable and network content is crawled via scripts, differentiated processing shall be performed according to data types: for regular webpage texts, remove redundant contents including HTML tags, style codes, advertising fragments, invalid comments and redundant blank lines, retain only valid main texts and truncate the content if it exceeds 8000 characters with a strict upper limit of 8000 characters for text output; for program source codes, no filtering or cleaning is required, keep the original codes, built-in comments, indentations, line breaks and original formats completely with no character limit on code output.
+14、When starting a persistent service in the background, ensure cross-platform compatibility: set start_new_session=True for Linux/Mac environments and creationflags=subprocess.CREATE_NEW_PROCESS_GROUP for Windows environments.
+15、For long-running tasks with unpredictable durations (such as large file downloads, model training, full tests, complex builds, etc.), synchronous blocking execution within the script is strictly prohibited. Instead, use subprocess.Popen to start the task in the background across platforms and write progress heartbeats to a local log file. After printing the PID, immediately call sys.exit() and set the tool's timeout_seconds to 15 seconds for startup verification only. Subsequently, monitor progress by checking the log file. If the task completes or there is no heartbeat update for an extended period, proactively call system commands (like kill -9 PID) to clean up background processes and prevent orphan processes from consuming resources. Only when the task itself supports timeout parameters or has a predictable duration can synchronous execution be performed within the script with a reasonable timeout_seconds setting.
 
 """
 
 
-PLANNING_PROMPT = (
-    "你是一个基于 CLI 的编程 Agent，你的名字是 Jason Li，专注于使用文件、命令、Python 脚本等工具完成开发任务。\n\n"
-    "在生成任务执行计划时，请遵循以下工作原则：\n"
-    "1、先检查工作目录并理解需求。\n"
-    "2、优先使用网络搜索类工具搜索网络实时信息，例如：天气、新闻、资讯等等。\n"
-    "3、所有代码文件生成、编辑、删除等操作均在工作目录中执行。如果用户没有指定具体目录，默认工作目录为工程的根目录。\n"
-    "4、如果需要，输出简洁的说明与下一步建议。\n"
-    "5、若涉及删除系统文件或执行危险命令，必须先向用户确认后方可执行。\n"
-    "6、当用户输入指令：/task-start 的时候，直接回复：请输入你的第一条初始提示。\n"
-    "7、遇到信息盲区时，严禁主观臆测，请优先使用搜索工具补齐信息缺口，确保回答精准有据。\n"
-    "8、如果用户想“读取/识别其他二进制文件”，你必须明确告知：我无法直接读取或理解通用二进制文件内容。\n"
-    "9、如果用户想“查看图片内容”，应优先调用图片读取工具将图片转成 base64 或视觉消息格式，再将其发送给支持多模态的模型。\n"
-    "10、对于图片类任务，优先使用图片工具而不是尝试直接读取二进制原始内容。\n"
-    "11、基于上下文和历史对话，先梳理用户的完整意图，再生成一份清晰、可执行的步骤清单；随后按步骤逐步完成任务，并在每个步骤完成后反馈执行状态和进度。\n"
-    "12、在任何需要执行命令的步骤中，先判断该命令属于短时命令还是持久命令，并在任务清单中明确写出你的判断说明：短时命令如 ls、pytest、python -m compileall 等应同步执行并等待结果；持久命令如 npm run dev、python app.py、uvicorn、flask run、serve、http.server 等应优先以后台方式启动，并在必要时用健康检查确认服务已就绪。\n\n"
-    "13、无法调用官方联网检索工具而通过脚本抓取网络内容时需区分数据类型处理，抓取普通网页文本需剔除 HTML 标签、样式代码、广告碎片、无效注释、多余空行等冗余内容，仅留存有效正文且文本超出 8000 字符则截断，文本输出上限为 8000 字符，抓取程序源代码则无需过滤，完整保留原始代码、自带注释、缩进换行与原有格式，代码输出无字符数量限制。\n\n"
-    "请严格按照以下格式输出结果：\n\n"
-    "用户原始指令：......\n\n"
-    "结合上下文得到用户的完整意图：.....\n\n"
-    "接下来按照这个步骤逐步执行完成任务：\n\n"
-    "1、第一步：......\n"
-    "2、第二步：......\n"
-    "......"
-)
+PLANNING_PROMPT = """
+你是一个基于 CLI 的编程 Agent，你的名字是 Jason Li，专注于使用文件、命令、Python 脚本等工具完成开发任务。
+
+在生成任务执行计划时，请遵循以下工作原则：
+
+1、先检查工作目录并理解需求。
+2、优先使用网络搜索类工具搜索网络实时信息，例如：天气、新闻、资讯等等。
+3、所有代码文件生成、编辑、删除等操作均在工作目录中执行。如果用户没有指定具体目录，默认工作目录为工程的根目录。
+4、如果需要，输出简洁的说明与下一步建议。
+5、若涉及删除系统文件或执行危险命令，必须先向用户确认后方可执行。
+6、当用户输入指令：/task-start 的时候,直接回复：请输入你的第一条初始提示。
+7、遇到信息盲区时，严禁主观臆测，请优先使用搜索工具补齐信息缺口，确保回答精准有据。
+8、如果用户想“读取/识别其他二进制文件”，你必须明确告知：我无法直接读取或理解通用二进制文件内容。
+9、如果用户想“查看图片内容”，应优先调用图片读取工具将图片转成 base64 或视觉消息格式，再将其发送给支持多模态的模型。
+10、对于图片类任务，优先使用图片工具而不是尝试直接读取二进制原始内容。
+11、当用户输入一条任务指令时，如果是详细的任务清单，你就理解用户要求逐步完成工作，同时每个步骤执行完毕要反馈状态和进度。
+12、使用 execute_python_script 时必须在脚本内自行管理进程生命周期：若是 ls、pytest、build 等短命令用 subprocess.run 显式设置 timeout，若是 npm run dev、flask run 等常驻服务用 subprocess.Popen 脱离终端启动并在脚本内轮询健康检查 URL，确认就绪后打印 PID 并立即 sys.exit() 退出以防触发 360 秒强制超时。
+13、无法调用官方联网检索工具而通过脚本抓取网络内容时需区分数据类型处理，抓取普通网页文本需剔除 HTML 标签、样式代码、广告碎片、无效注释、多余空行等冗余内容，仅留存有效正文且文本超出 8000 字符则截断，文本输出上限为 8000 字符，抓取程序源代码则无需过滤，完整保留原始代码、自带注释、缩进换行与原有格式，代码输出无字符数量限制。
+14、脱离终端启动常驻服务时务必兼顾跨平台兼容：Linux/Mac 环境设置 start_new_session=True，Windows 环境设置 creationflags=subprocess.CREATE_NEW_PROCESS_GROUP。
+15、凡耗时不可控的超长任务（如大文件下载、模型训练、全量测试、复杂构建等），严禁在脚本内同步阻塞，必须用 subprocess.Popen 跨平台脱离终端启动并将进度心跳写入本地日志文件，打印 PID 后立即 sys.exit()，工具 timeout_seconds 设为 15 秒仅验证启动；后续须通过检查日志监控进度，若发现任务完成或长时间无心跳更新，必须主动调用系统命令（如 kill -9 PID）清理后台进程以防孤儿进程耗尽资源；仅在任务自身支持超时参数或耗时可预估时，方可在脚本内同步执行并设合理 timeout_seconds。
+
+
+请严格按照以下格式输出结果：
+
+用户原始指令：......
+
+结合上下文得到用户的完整意图：.....
+
+接下来按照这个步骤逐步执行完成任务：
+1、第一步：......
+2、第二步：......
+......
+
+"""
 
 
 TRANSLATIONS = {
@@ -289,7 +305,7 @@ def t(key: str, **kwargs: Any) -> str:
 
 
 UI_SYSTEM_LANGUAGE = "en"
-APPLICATION_VERSION = "0.2.2"
+APPLICATION_VERSION = "0.2.3"
 DEFAULT_SYSTEM_PROMPT = t("system_prompt")
 WORKSPACE_DIR = ROOT / "workspace"
 LOG_DIR = ROOT / "logs"
@@ -475,38 +491,31 @@ TOOL_DEFINITIONS = [
             },
         },
     },
-    {
-        "type": "function",
-        "function": {
-            "name": "execute_command",
-            "description": t("execute_command_desc"),
-            "parameters": {
-                "type": "object",
-                "properties": {
-                    "command": {"type": "string", "description": t("command_desc")},
-                    "cwd": {"type": "string", "description": t("cwd_desc")},
-                    "timeout_seconds": {"type": "integer", "description": "Maximum runtime in seconds before the background process is terminated automatically."},
-                    "output_log_path": {"type": "string", "description": "Optional path to a log file where stdout/stderr will be written."},
-                },
-                "required": ["command", "cwd"],
-            },
-        },
-    },
     {
         "type": "function",
         "function": {
             "name": "execute_python_script",
-            "description": t("execute_python_script_desc"),
+            "description": "Execute a Python script or a block of Python code. Use the 'timeout_seconds' parameter to control the maximum execution time and prevent the process from hanging indefinitely.",
             "parameters": {
                 "type": "object",
                 "properties": {
-                    "script": {"type": "string", "description": t("script_desc")},
-                    "cwd": {"type": "string", "description": t("script_cwd_desc")},
+                    "script": {
+                        "type": "string",
+                        "description": "The Python script content to execute."
+                    },
+                    "cwd": {
+                        "type": "string",
+                        "description": "The working directory for the script execution."
+                    },
+                    "timeout_seconds": {
+                        "type": "integer",
+                        "description": "Maximum execution time in seconds before the process is terminated. Defaults to 120. Set a shorter timeout for quick commands to avoid waiting."
+                    }
                 },
-                "required": ["script", "cwd"],
-            },
-        },
-    },
+                "required": ["script", "cwd"]
+            }
+        }
+    }
 ]
 ACTIVE_MCP_TOOL_DEFINITIONS: list[dict[str, Any]] = []
 ACTIVE_MCP_TOOL_CONFIG: dict[str, Any] = {}
@@ -1211,51 +1220,193 @@ def wait_for_health_check(url: str, timeout_seconds: int = 20) -> bool:
 
 def run_subprocess_command(command: Any, cwd: str, shell: bool = False, timeout: int | None = None) -> tuple[int, str, str]:
     safe_cwd = resolve_execution_cwd(cwd, Path.cwd())
+    
+    # 跨平台进程隔离配置
+    popen_kwargs = {
+        "cwd": safe_cwd,
+        "stdout": subprocess.PIPE,
+        "stderr": subprocess.PIPE,
+        "stdin": subprocess.DEVNULL,  # 根治等待输入导致的卡死！
+        "text": True,
+        "encoding": "utf-8",
+        "errors": "replace",
+    }
+    if platform.system() == "Windows":
+        popen_kwargs["creationflags"] = subprocess.CREATE_NEW_PROCESS_GROUP
+    else:
+        popen_kwargs["start_new_session"] = True # 创建新进程组，便于后续杀整棵树
+
     try:
-        proc = subprocess.Popen(
-            command,
-            cwd=safe_cwd,
-            shell=shell,
-            stdout=subprocess.PIPE,
-            stderr=subprocess.PIPE,
-            text=True,
-            encoding="utf-8",
-            errors="replace",
-        )
+        proc = subprocess.Popen(command, shell=shell, **popen_kwargs)
     except (FileNotFoundError, NotADirectoryError, OSError) as exc:
         logger.warning(t("tool_subprocess_failed"), cwd, safe_cwd, exc)
-        proc = subprocess.Popen(
-            command,
-            cwd=str(Path.cwd()),
-            shell=shell,
-            stdout=subprocess.PIPE,
-            stderr=subprocess.PIPE,
-            text=True,
-            encoding="utf-8",
-            errors="replace",
-        )
+        proc = subprocess.Popen(command, cwd=str(Path.cwd()), shell=shell, **popen_kwargs)
 
     try:
         stdout, stderr = proc.communicate(timeout=timeout)
     except subprocess.TimeoutExpired:
-        proc.terminate()
+        # 超时后杀掉整个进程树，防止孤儿进程
         try:
-            proc.wait(timeout=5)
-        except subprocess.TimeoutExpired:
-            proc.kill()
-            proc.wait(timeout=5)
+            if platform.system() == "Windows":
+                subprocess.run(["taskkill", "/F", "/T", "/PID", str(proc.pid)], capture_output=True, timeout=5)
+            else:
+                os.killpg(os.getpgid(proc.pid), signal.SIGTERM)
+                proc.wait(timeout=3)
+                if proc.poll() is None:
+                    os.killpg(os.getpgid(proc.pid), signal.SIGKILL)
+        except Exception:
+            pass
+        finally:
+            try: proc.kill()
+            except: pass
         return -1, "", f"Command timed out after {timeout} seconds"
     except KeyboardInterrupt:
-        proc.terminate()
+        # 处理用户 Ctrl+C 中断
         try:
-            proc.wait(timeout=5)
-        except subprocess.TimeoutExpired:
-            proc.kill()
-            proc.wait(timeout=5)
+            if platform.system() == "Windows":
+                subprocess.run(["taskkill", "/F", "/T", "/PID", str(proc.pid)], capture_output=True, timeout=5)
+            else:
+                os.killpg(os.getpgid(proc.pid), signal.SIGTERM)
+        except Exception:
+            pass
         raise
+
     return proc.returncode, stdout or "", stderr or ""
 
 
+
+import os
+import signal
+import subprocess
+import uuid
+import time
+import platform
+from pathlib import Path
+
+def handle_execute_command(args):
+    command = args.get("command")
+    if not command:
+        return {"status": "error", "content": "Missing 'command' argument."}
+    
+    cwd = resolve_execution_cwd(args.get("cwd"), Path.cwd())
+    
+    # 解析命令类型参数
+    is_background = args.get("background", False)
+    
+    # ================= 路径 A: 常驻服务 (保留你原有的优秀逻辑) =================
+    if is_background:
+        output_log_path = args.get("output_log_path") or args.get("log_path")
+        if not output_log_path:
+            output_log_path = ROOT / "logs" / "background" / f"cmd_{datetime.now().strftime('%Y%m%d_%H%M%S')}_{os.getpid()}.log"
+            
+        result = start_background_process(command, cwd, timeout_seconds=None, output_log_path=output_log_path)
+        
+        if result.get("status") == "ok":
+            health_check_url = args.get("health_check_url")
+            if health_check_url:
+                try:
+                    ready = wait_for_health_check(str(health_check_url), timeout_seconds=int(args.get("health_check_timeout", 20)))
+                    result["health_check_ready"] = ready
+                    result["content"] = f"Started background process (pid={result['pid']})" + (" and health check succeeded." if ready else " but health check did not succeed yet.")
+                except Exception:
+                    result["health_check_ready"] = False
+                    result["content"] = f"Started background process (pid={result['pid']})"
+            
+            time.sleep(0.5) # 防止竞态
+            result["output_tail"] = _read_text_file_tail(output_log_path, max_chars=4000)
+            return result
+        return result
+        
+    # ================= 路径 B: 一次性命令 (新增 Sentinel 同步等待逻辑) =================
+    else:
+        timeout_seconds = int(args.get("timeout_seconds") or args.get("timeout") or 120)
+        
+        # 生成唯一哨兵并组装命令 (跨平台适配错误码输出)
+        sentinel = f"@@CMD_DONE_{uuid.uuid4().hex}@@"
+        if platform.system() == "Windows":
+            full_cmd = f"{command}\necho {sentinel} %errorlevel%\n"
+        else:
+            full_cmd = f"{command}\necho {sentinel} $?\n"
+        
+        # 构建启动参数 (跨平台适配进程组)
+        popen_kwargs = {
+            "shell": True,
+            "cwd": str(cwd),
+            "stdout": subprocess.PIPE,
+            "stderr": subprocess.STDOUT,
+            "text": True,
+            "bufsize": 1,
+        }
+        
+        if platform.system() == "Windows":
+            popen_kwargs["creationflags"] = subprocess.CREATE_NEW_PROCESS_GROUP
+        else:
+            popen_kwargs["start_new_session"] = True
+            
+        process = subprocess.Popen(full_cmd, **popen_kwargs)
+        
+        output_lines = []
+        timed_out = False
+        start_time = time.time()
+        
+        try:
+            while True:
+                line = process.stdout.readline()
+                if not line:
+                    if time.time() - start_time > timeout_seconds:
+                        timed_out = True
+                        break
+                    continue
+                
+                if sentinel in line:
+                    # 提取退出码
+                    try:
+                        exit_code = int(line.split(sentinel)[-1].strip().rstrip())
+                    except:
+                        exit_code = -1
+                    break
+                else:
+                    output_lines.append(line)
+                    if len(output_lines) > 5000:
+                        output_lines.pop(0)
+                        
+                if time.time() - start_time > timeout_seconds:
+                    timed_out = True
+                    break
+        finally:
+            # 超时或完成后，杀掉整个进程树 (跨平台适配)
+            if process.poll() is None:
+                try:
+                    if platform.system() == "Windows":
+                        # Windows: taskkill 强杀整个进程树
+                        subprocess.run(["taskkill", "/F", "/T", "/PID", str(process.pid)], 
+                                      capture_output=True, timeout=5)
+                    else:
+                        # Unix: 杀整个进程组
+                        os.killpg(os.getpgid(process.pid), signal.SIGTERM)
+                        time.sleep(1)
+                        if process.poll() is None:
+                            os.killpg(os.getpgid(process.pid), signal.SIGKILL)
+                except Exception:
+                    pass
+        
+        content = "".join(output_lines)[-4000:]
+        
+        if timed_out:
+            return {
+                "status": "timeout",
+                "exit_code": None,
+                "content": f"{content}\n[ERROR] Command timed out after {timeout_seconds} seconds and was forcefully terminated.\n[Hint] If this is a dev server, please use background=true."
+            }
+        else:
+            return {
+                "status": "success" if exit_code == 0 else "error",
+                "exit_code": exit_code,
+                "content": content
+            }
+
+
+
 def execute_tool_call(tool_call: Any) -> dict[str, Any]:
     name = getattr(tool_call.function, "name", "")
     args = safe_parse_tool_args(getattr(tool_call.function, "arguments", {}))
@@ -1454,46 +1605,6 @@ def execute_tool_call(tool_call: Any) -> dict[str, Any]:
         logger.info("list_dir result: %s", result)
         return result
 
-    if name == "execute_command":
-        command = args.get("command")
-        if not command:
-            result = {"status": "error", "content": t("tool_missing_arg", name="execute_command", arg="command")}
-            logger.error("execute_command missing command argument, raw args: %s", args)
-            return result
-        cwd = resolve_execution_cwd(args.get("cwd"), Path.cwd())
-
-        timeout_seconds = None
-        timeout_value = args.get("timeout_seconds") or args.get("timeout")
-        if timeout_value is not None:
-            try:
-                timeout_seconds = int(timeout_value)
-            except (TypeError, ValueError):
-                timeout_seconds = None
-
-        output_log_path = args.get("output_log_path") or args.get("log_path")
-        if not output_log_path:
-            output_log_path = ROOT / "logs" / "background" / f"cmd_{datetime.now().strftime('%Y%m%d_%H%M%S')}_{os.getpid()}.log"
-        result = start_background_process(command, cwd, timeout_seconds=timeout_seconds, output_log_path=output_log_path)
-        if result.get("status") == "ok":
-            health_check_url = args.get("health_check_url")
-            if health_check_url:
-                try:
-                    ready = wait_for_health_check(str(health_check_url), timeout_seconds=int(args.get("health_check_timeout", 20)))
-                    result["health_check_ready"] = ready
-                    result["content"] = (
-                        f"Started background process (pid={result['pid']})"
-                        + (" and confirmed health check succeeded." if ready else " but health check did not succeed yet.")
-                    )
-                except Exception:
-                    result["health_check_ready"] = False
-                    result["content"] = f"Started background process (pid={result['pid']})"
-            result["output_tail"] = _read_text_file_tail(output_log_path, max_chars=4000)
-            logger.info("execute_command background result: %s", result)
-            return result
-
-        logger.info("execute_command result: %s", result)
-        return result
-
     if name == "execute_python_script":
         script = args.get("script")
         if not script:
@@ -1504,7 +1615,17 @@ def execute_tool_call(tool_call: Any) -> dict[str, Any]:
         script_path = Path(cwd) / "__cli_temp_script__.py"
         script_path.parent.mkdir(parents=True, exist_ok=True)
         script_path.write_text(script, encoding="utf-8")
-        returncode, stdout, stderr = run_subprocess_command([sys.executable, str(script_path)], cwd, timeout=TOOL_SUBPROCESS_TIMEOUT)
+        
+        # 获取自定义超时，默认 120 秒，最大不超过 360 秒
+        timeout_seconds = int(args.get("timeout_seconds") or 120)
+        timeout_seconds = min(max(timeout_seconds, 10), TOOL_SUBPROCESS_TIMEOUT)
+        
+        returncode, stdout, stderr = run_subprocess_command(
+            [sys.executable, str(script_path)], 
+            cwd, 
+            shell=False, 
+            timeout=timeout_seconds
+        )
         response = {
             "status": "ok" if returncode == 0 else "error",
             "content": stdout + stderr,
@@ -1513,6 +1634,7 @@ def execute_tool_call(tool_call: Any) -> dict[str, Any]:
         logger.info("execute_python_script result: %s", response)
         return response
 
+
     if name in {item["function"]["name"] for item in ACTIVE_MCP_TOOL_DEFINITIONS}:
         logger.info("Executing MCP tool: %s, args: %s", name, args)
         return run_mcp_tool(name, args)

{prompt_copilot_cli-0.2.2 → prompt_copilot_cli-0.2.3/prompt_copilot_cli.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: prompt-copilot-cli
-Version: 0.2.2
+Version: 0.2.3
 Summary: A lightweight terminal-based coding agent with file tools, command execution, multimodal image support, and MCP integration.
 Author: Jason Li
 License-Expression: MIT

{prompt_copilot_cli-0.2.2 → prompt_copilot_cli-0.2.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "prompt-copilot-cli"
-version = "0.2.2"
+version = "0.2.3"
 description = "A lightweight terminal-based coding agent with file tools, command execution, multimodal image support, and MCP integration."
 readme = "README.md"
 license = "MIT"