diff --git a/mcp_center/servers/oe_cli_mcp_server/mcp_tools/base_tools/cmd_executor_tool/tool.py b/mcp_center/servers/oe_cli_mcp_server/mcp_tools/base_tools/cmd_executor_tool/tool.py index 985b4b571ddb3563a87d97021c1ba782e67b3e60..1c80cc3edb45c38d48d894c676d7786f7b90d125 100644 --- a/mcp_center/servers/oe_cli_mcp_server/mcp_tools/base_tools/cmd_executor_tool/tool.py +++ b/mcp_center/servers/oe_cli_mcp_server/mcp_tools/base_tools/cmd_executor_tool/tool.py @@ -1,8 +1,9 @@ import asyncio from typing import Union, Optional import subprocess -from config.public.base_config_loader import BaseConfig,LanguageEnum - +from mcp_tools.base_tools.proc_tool.base import replace_cmd_with_abs_path +from config.public.base_config_loader import BaseConfig, LanguageEnum +import re # Copyright (c) Huawei Technologies Co., Ltd. 2023-2024. All rights reserved. @@ -17,9 +18,9 @@ async def cmd_executor_tool( :param timeout: 手动指定超时时间（秒），可选 :return: 结构化字典结果，包含success、message、result、target、timeout_used """ - # -------------------------- 读取语言配置（优先级：传入参数 > 配置文件） -------------------------- - - lang = BaseConfig().get_config().public_config.language + # -------------------------- 读取语言配置 -------------------------- + # 改为使用传入的参数，方便测试多语言 + current_lang = BaseConfig().get_config().public_config.language # -------------------------- 初始化返回结果字典 -------------------------- response = { @@ -32,97 +33,109 @@ async def cmd_executor_tool( # -------------------------- 命令为空校验 -------------------------- if not command: - response["message"] = "请提供需要执行的命令" if lang == LanguageEnum.ZH else "please give me the command to execute" + response["message"] = "请提供需要执行的命令" if current_lang == LanguageEnum.ZH else "please give me the command to execute" return response # -------------------------- 超时时间配置与处理 -------------------------- - # 定义常见指令的默认超时时间（秒），可根据需求扩展 cmd_timeout_map = { - # 快速指令：短超时 - "ls": 5, - "pwd": 5, - "echo": 5, - "cat": 10, - "grep": 10, - # 中等耗时指令 - "ping": 30, - "curl": 30, - # 长耗时指令 - "yum": 300, - "apt": 300, - "docker": 600, - "scp": 600, + "ls": 5, "pwd": 5, "echo": 5, "cat": 10, "grep": 10, + "ping": 30, "curl": 30, "yum": 300, "apt": 300, "docker": 600, "scp": 600, } - # Shell脚本执行的默认超时时间（秒） SHELL_SCRIPT_DEFAULT_TIMEOUT = 600 def get_final_timeout(cmd: str) -> int: - """确定最终超时时间，优先级：用户指定 > Shell脚本默认 > 普通指令默认 > 全局默认15秒""" - # 优先级1：用户手动指定超时（校验合法性） + """确定最终超时时间""" if timeout is not None: try: t = int(timeout) return t if t > 0 else 15 except (ValueError, TypeError): return 15 - # 优先级2：执行Shell脚本的指令，使用专属超时 cmd_lower = cmd.lower() - if ".sh" in cmd_lower or cmd_lower.startswith("bash ") or cmd_lower.startswith("sh "): - return SHELL_SCRIPT_DEFAULT_TIMEOUT - # 优先级3：匹配普通指令的默认超时 - for cmd_key, t in cmd_timeout_map.items(): - if cmd_key in cmd_lower: - return t - # 优先级4：全局默认超时 - return 15 + split_pattern = re.compile(r'(\|\||&&|\||;|&)') # 匹配所有命令连接符 + cmd_parts = [part.strip() + for part in split_pattern.split(cmd_lower) if part.strip()] + t_used = 0 + for part in cmd_parts: + if part in ["||", "&&", "|", ";", "&"]: + continue + if ".sh" in part or part.startswith("bash ") or part.startswith("sh "): + t_used += SHELL_SCRIPT_DEFAULT_TIMEOUT + continue + for cmd_key, t in cmd_timeout_map.items(): + if part.startswith(cmd_key) or part == cmd_key: + t_used += t + return t_used final_timeout = get_final_timeout(command) - response["timeout_used"] = final_timeout # 记录实际使用的超时时间 + response["timeout_used"] = final_timeout + command = replace_cmd_with_abs_path(command) + # -------------------------- 本地命令执行 -------------------------- - # -------------------------- 本地命令执行（同步逻辑，供线程池调用） -------------------------- def local_exec_sync(): - """同步执行本地命令，返回执行结果和错误信息""" + """同步执行本地命令，优化空结果和错误处理""" try: + # 关键修改1：移除check=True，手动处理退出码 result = subprocess.run( command, shell=True, - check=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True ) - # 执行成功，返回输出内容 - return True, result.stdout.strip(), "" - except subprocess.CalledProcessError as e: - # 命令执行返回非0，返回错误信息 - return False, "", e.stderr.strip() + + # 提取输出和错误信息 + stdout = result.stdout.strip() + stderr = result.stderr.strip() + + # 关键修改2：区分不同场景 + if result.returncode == 0: + # 场景1：命令执行成功（退出码0） + if not stdout: + # 子场景1.1：执行成功但无输出结果 + return True, "", "命令执行成功但未返回任何结果" if current_lang == LanguageEnum.ZH else "Command executed successfully but no results returned" + # 子场景1.2：执行成功且有输出结果 + return True, stdout, "" + else: + # 场景2：命令执行失败（非0退出码） + # 特殊处理grep命令：退出码1表示无匹配结果，不算真正的执行失败 + cmd_lower = command.lower() + if "grep" in cmd_lower and result.returncode == 1: + return True, "", "未找到匹配内容" if current_lang == LanguageEnum.ZH else "No matching content found" + + # 真正的执行失败，合并错误信息 + error_msg = stderr or stdout or f"命令执行失败，退出码：{result.returncode}" + return False, "", error_msg + except Exception as e: - # 其他异常，返回异常信息 - return False, "", str(e) + # 场景3：其他异常（如命令不存在、权限问题等） + return False, "", f"执行异常：{str(e)}" # -------------------------- 超时控制执行 -------------------------- try: loop = asyncio.get_running_loop() - # 用线程池执行同步的本地命令，并用wait_for控制超时 exec_success, exec_result, exec_error = await asyncio.wait_for( loop.run_in_executor(None, local_exec_sync), timeout=final_timeout ) if exec_success: - # 命令执行成功 + # 命令执行成功（包括空结果场景） response["success"] = True - response["message"] = "命令执行成功" if lang == LanguageEnum.ZH else "Command executed successfully" + # 优先使用自定义提示，无则用默认成功提示 + response["message"] = exec_error if exec_error else ( + "命令执行成功" if current_lang == LanguageEnum.ZH else "Command executed successfully") response["result"] = exec_result else: - # 命令执行失败 - response["message"] = f"命令执行出错：{exec_error}" if lang == LanguageEnum.ZH else f"Command execution failed: {exec_error}" + # 命令真正执行失败 + if not exec_error: + exec_error = "未知错误" if current_lang == LanguageEnum.ZH else "Unknown error" + response["message"] = f"命令执行出错：{exec_error}" if current_lang == LanguageEnum.ZH else f"Command execution failed: {exec_error}" except asyncio.TimeoutError: - # 命令执行超时 - response["message"] = f"本地执行命令超时（{final_timeout}秒），已终止执行" if lang == LanguageEnum.ZH else f"Local command execution timed out ({final_timeout} seconds), terminated" + response[ + "message"] = f"本地执行命令超时（{final_timeout}秒），已终止执行" if current_lang == LanguageEnum.ZH else f"Local command execution timed out ({final_timeout} seconds), terminated" except Exception as e: - # 其他执行异常（如线程池错误） - response["message"] = f"本地执行命令出错：{str(e)}" if lang == LanguageEnum.ZH else f"Local command execution failed: {str(e)}" + response["message"] = f"本地执行命令出错：{str(e)}" if current_lang == LanguageEnum.ZH else f"Local command execution failed: {str(e)}" - return response \ No newline at end of file + return response diff --git a/mcp_center/servers/oe_cli_mcp_server/mcp_tools/base_tools/proc_tool/base.py b/mcp_center/servers/oe_cli_mcp_server/mcp_tools/base_tools/proc_tool/base.py index 7b3c1e23f9511c9c5a212082ea62f1cdaaedab20..e55e60141bde330f0bf73c1910dc5812c5990976 100644 --- a/mcp_center/servers/oe_cli_mcp_server/mcp_tools/base_tools/proc_tool/base.py +++ b/mcp_center/servers/oe_cli_mcp_server/mcp_tools/base_tools/proc_tool/base.py @@ -5,12 +5,14 @@ import re from enum import Enum from typing import Dict, List, Optional, Union from config.public.base_config_loader import LanguageEnum, BaseConfig - +import shlex # 初始化日志（仅保留基础配置） logger = logging.getLogger("proc_tool") logger.setLevel(logging.INFO) # ========== 枚举类定义（不变，保留核心操作） ========== + + class ProcActionEnum(str, Enum): LIST = "list" # 所有进程 FIND = "find" # 按名称/PID查询 @@ -21,12 +23,16 @@ class ProcActionEnum(str, Enum): KILL = "kill" # 强制终止进程 # ========== 通用工具函数（精简，保留必要功能） ========== + + def get_language() -> LanguageEnum: return BaseConfig().get_config().public_config.language + def is_zh() -> bool: return get_language() == LanguageEnum.ZH + def init_result_dict(target_host: str = "127.0.0.1") -> Dict: """初始化返回结果（简洁格式）""" return { @@ -37,6 +43,7 @@ def init_result_dict(target_host: str = "127.0.0.1") -> Dict: "proc_actions": [] } + def parse_proc_actions(action_list: List[str]) -> List[ProcActionEnum]: """解析操作类型（仅保留必要校验）""" valid_values = [e.value for e in ProcActionEnum] @@ -54,40 +61,118 @@ def parse_proc_actions(action_list: List[str]) -> List[ProcActionEnum]: return parsed # ========== 核心工具函数（精简，无复杂嵌套） ========== -def get_cmd_path(cmd: str) -> Optional[str]: - """获取命令绝对路径（简洁实现，避免复杂逻辑）""" - # 优先遍历常见路径（OpenEuler默认路径） - common_paths = ["/usr/bin", "/bin", "/usr/sbin", "/sbin"] - for path in common_paths: - cmd_path = os.path.join(path, cmd) - if os.path.exists(cmd_path) and os.access(cmd_path, os.X_OK): - return cmd_path - # 路径不存在返回None - logger.warning(f"命令不存在：{cmd}（未在常见路径中找到）") - return None - -def run_cmd(cmd: List[str]) -> Optional[str]: - """执行命令（精简异常处理，只捕获关键错误）""" - cmd_path = get_cmd_path(cmd[0]) - if not cmd_path: - return None # 命令不存在直接返回None - cmd[0] = cmd_path # 替换为绝对路径 + +def get_absolute_command_path(cmd_name: str) -> str: + """ + 获取单个命令的绝对路径（优先用 which，兜底常见路径） + :param cmd_name: 命令名（如 ps、grep、python） + :return: 绝对路径，找不到返回原命令名 + """ + # 方法1：用系统 which 命令（最准确，兼容所有系统） try: - logger.info(f"执行命令：{' '.join(cmd)}") + result = subprocess.run( + ["which", cmd_name], + stdout=subprocess.PIPE, + stderr=subprocess.PIPE, + text=True, + check=True, + timeout=5 + ) + abs_path = result.stdout.strip() + logger.info(f"找到命令 {cmd_name} 的绝对路径：{abs_path}") + return abs_path + except (subprocess.CalledProcessError, subprocess.TimeoutExpired): + # 方法2：兜底遍历常见路径（适配无 which 的极简系统） + common_paths = ["/usr/bin", "/bin", "/usr/sbin", + "/sbin", "/usr/local/bin", "/usr/local/sbin"] + for path in common_paths: + abs_path = os.path.join(path, cmd_name) + if os.path.exists(abs_path) and os.access(abs_path, os.X_OK): + logger.info(f"兜底找到命令 {cmd_name} 的绝对路径：{abs_path}") + return abs_path + # 找不到路径，返回原命令名（执行时可能报错，由上层处理） + logger.warning(f"未找到命令 {cmd_name} 的绝对路径，将使用原命令执行") + return cmd_name + + +def replace_cmd_with_abs_path(cmd_str: str) -> str: + """ + 将命令字符串中的主程序替换为绝对路径（支持复杂命令：管道、参数、引号） + :param cmd_str: 原始命令字符串（如 "ps aux | grep python"、"echo 'hello world'"） + :return: 替换后的命令字符串（如 "/usr/bin/ps aux | /usr/bin/grep python"） + """ + # 步骤1：拆分命令为「原子单元」（按管道/分号/&&/|| 拆分，保留连接符） + import re + split_pattern = re.compile(r'(\|\||&&|\||;|&)') # 匹配所有命令连接符 + cmd_parts = [part.strip() + for part in split_pattern.split(cmd_str) if part.strip()] + + rebuilt_parts = [] + for part in cmd_parts: + # 如果是连接符（如 |、&&、;），直接保留 + if part in ["||", "&&", "|", ";", "&"]: + rebuilt_parts.append(part) + continue + + # 步骤2：安全拆分子命令（处理引号/空格，如 echo "hello world"） + try: + sub_cmd_parts = shlex.split(part) + if not sub_cmd_parts: + rebuilt_parts.append(part) + continue + except ValueError as e: + logger.error(f"解析子命令 {part} 失败：{e}，保留原内容") + rebuilt_parts.append(part) + continue + + # 步骤3：替换主程序为绝对路径（如 ps → /usr/bin/ps） + main_cmd = sub_cmd_parts[0] + abs_main_cmd = get_absolute_command_path(main_cmd) + sub_cmd_parts[0] = abs_main_cmd + + # 步骤4：重组子命令（恢复引号/空格格式） + rebuilt_sub_cmd = shlex.join(sub_cmd_parts) + rebuilt_parts.append(rebuilt_sub_cmd) + + # 步骤5：拼接所有部分，得到最终命令字符串 + final_cmd = " ".join(rebuilt_parts) + logger.info(f"原始命令：{cmd_str}") + logger.info(f"绝对路径命令：{final_cmd}") + return final_cmd + + +def run_cmd(cmd: list[str], timeout: int = 10) -> Optional[str]: + """ + 重构命令执行函数：支持shell管道命令，适配ps命令的特殊场景 + :param cmd: 完整的shell命令字符串（支持管道、重定向等） + :param timeout: 超时时间，默认10秒 + :return: 命令执行结果（stdout），失败返回None + """ + # 提取主命令（如ps）并校验是否存在 + + try: + logger.info(f"执行命令：{cmd}") + # 启用shell=True支持管道符，同时替换主命令为绝对路径（避免环境变量问题） + cmd = replace_cmd_with_abs_path(" ".join(cmd)) result = subprocess.run( cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, - text=True, check=True, timeout=10 + text=True, shell=True, check=True, timeout=timeout ) return result.stdout.strip() - except (subprocess.CalledProcessError, subprocess.TimeoutExpired) as e: + except subprocess.CalledProcessError as e: logger.error(f"命令执行失败：{e.stderr.strip() or str(e)}") return None + except subprocess.TimeoutExpired: + logger.error(f"命令执行超时（{timeout}秒）") + return None except Exception as e: logger.error(f"系统调用异常：{str(e)}") return None # ========== 进程管理核心类（极简实现，易阅读） ========== + + class ProcessManager: def __init__(self): self.zh = is_zh() # 提前判断语言，避免重复调用 @@ -97,9 +182,15 @@ class ProcessManager: return zh if self.zh else en # ---------- 查：进程查询（核心功能，无多余嵌套） ---------- - def list_all_procs(self) -> List[Dict]: + def list_procs(self, top_k: Optional[int] = None) -> List[Dict]: """列出所有进程（精简解析逻辑）""" - output = run_cmd(["ps", "aux"]) + if top_k is not None and (not isinstance(top_k, int) or top_k <= 0): + return [{"error": self._msg("top_k必须为正整数", "top_k must be positive integer")}] + if top_k is not None: + output = run_cmd(["ps", "aux", "--sort=-%cpu", + "|", "head", f"-n{top_k + 1}"]) + else: + output = run_cmd(["ps", "aux"]) if not output: return [{"error": self._msg("ps命令执行失败", "ps command failed")}] @@ -116,7 +207,8 @@ class ProcessManager: # 只转换关键数字字段（避免复杂处理） for key in ["pid", "cpu", "mem"]: if key in proc: - proc[key] = float(proc[key]) if "." in proc[key] else int(proc[key]) + proc[key] = float( + proc[key]) if "." in proc[key] else int(proc[key]) procs.append(proc) return procs @@ -143,7 +235,8 @@ class ProcessManager: if not isinstance(pid, int) or pid <= 0: return {"error": self._msg("PID必须为正整数", "PID must be positive integer")} - output = run_cmd(["ps", "-p", str(pid), "-o", "pid,%cpu,%mem,rss,vsz,etime"]) + output = run_cmd(["ps", "-p", str(pid), "-o", + "pid,%cpu,%mem,rss,vsz,etime"]) if not output: return {"error": self._msg(f"PID {pid} 不存在或查询失败", f"PID {pid} not found or query failed")} @@ -158,7 +251,8 @@ class ProcessManager: # 转换数字字段 for key in ["pid", "cpupct", "mempct", "rss", "vsz"]: if key in stat: - stat[key] = float(stat[key]) if "." in stat[key] else int(stat[key]) + stat[key] = float( + stat[key]) if "." in stat[key] else int(stat[key]) return stat # ---------- 启/停/重启：systemd服务操作（简洁实现） ---------- @@ -220,7 +314,7 @@ class ProcessManager: batch_result = {} # 操作映射（减少if-else） action_map = { - ProcActionEnum.LIST: self.list_all_procs, + ProcActionEnum.LIST: self.list_procs, ProcActionEnum.FIND: lambda: self.find_proc(name=proc_name, pid=pid), ProcActionEnum.STAT: lambda: self.get_proc_stat(pid=pid), ProcActionEnum.START: lambda: self.start_proc(service_name=service_name), @@ -237,4 +331,4 @@ class ProcessManager: batch_result[action.value] = {"error": str(e)} logger.error(f"操作 {action.value} 失败：{str(e)}") - return batch_result \ No newline at end of file + return batch_result diff --git a/mcp_center/servers/oe_cli_mcp_server/mcp_tools/base_tools/proc_tool/config.json b/mcp_center/servers/oe_cli_mcp_server/mcp_tools/base_tools/proc_tool/config.json index 978cd9ae9895510bfe7d7fd7b17c9c38d1439af2..4ce5bf1f57870c838637b0f50038a49a48b88e4f 100644 --- a/mcp_center/servers/oe_cli_mcp_server/mcp_tools/base_tools/proc_tool/config.json +++ b/mcp_center/servers/oe_cli_mcp_server/mcp_tools/base_tools/proc_tool/config.json @@ -1,8 +1,8 @@ { "tools": { "proc_tool": { - "zh": "【进程管理工具】\n功能：支持进程的查看、启动、停止、强制终止等管理操作（基于ps/systemctl/kill命令）\n\n【核心提示】\n1. 操作类型（proc_actions）为枚举值列表，支持多选，可选枚举值及对应参数：\n - 查类：\n · list：所有进程（无需额外参数）\n · find：按名称/PID查询（需传proc_name或pid）\n · stat：进程资源占用（需传pid）\n - 启类：\n · start：启动服务（需传service_name，对应systemd服务名）\n · restart：重启服务（需传service_name）\n - 停类：\n · stop：停止服务（需传service_name）\n · kill：强制终止进程（需传pid）\n2. 输入格式示例：\n - 批量查询：[\"list\", \"find\"] + proc_name=\"nginx\"\n - 启停服务：[\"stop\", \"start\"] + service_name=\"nginx\"\n3. 语言配置：自动读取系统全局配置，不提供外部接口；\n4. 权限说明：启停/终止进程需root权限。\n\n【枚举类定义（必须遵守）】\n- ProcActionEnum（进程操作枚举）：list / find / stat / start / restart / stop / kill\n\n【参数详情】\n- proc_actions：进程操作列表（必填，枚举值见上方）\n- proc_name：进程名称（find操作必填）\n- pid：进程PID（find/stat/kill操作必填，正整数）\n- service_name：服务名称（start/restart/stop操作必填，对应systemd服务名）\n\n【返回值说明】\n- success：操作结果（True=成功，False=失败）\n- message：操作信息/错误提示（自动切换中英文）\n- result：操作结果（查类返回结构化列表/字典，启/停类返回命令日志）\n- target：执行目标（固定127.0.0.1）\n- proc_actions：已执行的操作列表", - "en": "【Process Management Tool】\nFunction: Supports process management (view/start/stop/force terminate) via ps/systemctl/kill commands\n\n【Core Guidelines】\n1. Proc actions (proc_actions) is an enum list, supports multiple selection. Enum values and required parameters:\n - Query:\n · list: All processes (no extra params)\n · find: Query by name/PID (requires proc_name or pid)\n · stat: Process resource usage (requires pid)\n - Start:\n · start: Start service (requires service_name, systemd service name)\n · restart: Restart service (requires service_name)\n - Stop:\n · stop: Stop service (requires service_name)\n · kill: Force terminate process (requires pid)\n2. Input examples:\n - Batch query: [\"list\", \"find\"] + proc_name=\"nginx\"\n - Start/stop service: [\"stop\", \"start\"] + service_name=\"nginx\"\n3. Language config: Auto-read global system config, no external interface;\n4. Permission note: Start/stop/terminate requires root privileges.\n\n【Enum Class Definition (Must Follow)】\n- ProcActionEnum (Proc Action Enum): list / find / stat / start / restart / stop / kill\n\n【Parameter Details】\n- proc_actions: Proc action list (required, enum values see above)\n- proc_name: Proc name (required for find)\n- pid: Proc PID (required for find/stat/kill, positive integer)\n- service_name: Service name (required for start/restart/stop, systemd service name)\n\n【Return Value Explanation】\n- success: Operation result (True=success, False=failure)\n- message: Operation info/error prompt (auto-switch between Chinese/English)\n- result: Operation result (query returns structured list/dict, start/stop returns command log)\n- target: Execution target (fixed 127.0.0.1)\n- proc_actions: Executed action list" + "zh": "【进程管理工具】\n功能：支持进程的查看、启动、停止、强制终止等管理操作（基于ps/systemctl/kill命令）\n\n【核心提示】\n1. 操作类型（proc_actions）为枚举值列表，支持多选，可选枚举值及对应参数：\n - 查类：\n · list：通过top_k参数控制返回进程的数量，top_k为None则返回所有进程\n · find：按名称/PID查询（需传proc_name或pid）\n · stat：进程资源占用（需传pid）\n - 启类：\n · start：启动服务（需传service_name，对应systemd服务名）\n · restart：重启服务（需传service_name）\n - 停类：\n · stop：停止服务（需传service_name）\n · kill：强制终止进程（需传pid）\n2. 输入格式示例：\n - 批量查询：[\"list\", \"find\"] + proc_name=\"nginx\"\n - 启停服务：[\"stop\", \"start\"] + service_name=\"nginx\"\n3. 语言配置：自动读取系统全局配置，不提供外部接口；\n4. 权限说明：启停/终止进程需root权限。\n\n【枚举类定义（必须遵守）】\n- ProcActionEnum（进程操作枚举）：list / find / stat / start / restart / stop / kill\n\n【参数详情】\n- proc_actions：进程操作列表（必填，枚举值见上方）\n- proc_name：进程名称（find操作必填）\n- pid：进程PID（find/stat/kill操作必填，正整数）\n- service_name：服务名称（start/restart/stop操作必填，对应systemd服务名）\n\n【返回值说明】\n- success：操作结果（True=成功，False=失败）\n- message：操作信息/错误提示（自动切换中英文）\n- result：操作结果（查类返回结构化列表/字典，启/停类返回命令日志）\n- target：执行目标（固定127.0.0.1）\n- proc_actions：已执行的操作列表", + "en": "【Process Management Tool】\nFunction: Supports process management (view/start/stop/force terminate) via ps/systemctl/kill commands\n\n【Core Guidelines】\n1. Proc actions (proc_actions) is an enum list, supports multiple selection. Enum values and required parameters:\n - Query:\n · list: Control number of returned processes via top_k parameter， if top_k is None, return all processes\n · find: Query by name/PID (requires proc_name or pid)\n · stat: Process resource usage (requires pid)\n - Start:\n · start: Start service (requires service_name, systemd service name)\n · restart: Restart service (requires service_name)\n - Stop:\n · stop: Stop service (requires service_name)\n · kill: Force terminate process (requires pid)\n2. Input examples:\n - Batch query: [\"list\", \"find\"] + proc_name=\"nginx\"\n - Start/stop service: [\"stop\", \"start\"] + service_name=\"nginx\"\n3. Language config: Auto-read global system config, no external interface;\n4. Permission note: Start/stop/terminate requires root privileges.\n\n【Enum Class Definition (Must Follow)】\n- ProcActionEnum (Proc Action Enum): list / find / stat / start / restart / stop / kill\n\n【Parameter Details】\n- proc_actions: Proc action list (required, enum values see above)\n- proc_name: Proc name (required for find)\n- pid: Proc PID (required for find/stat/kill, positive integer)\n- service_name: Service name (required for start/restart/stop, systemd service name)\n\n【Return Value Explanation】\n- success: Operation result (True=success, False=failure)\n- message: Operation info/error prompt (auto-switch between Chinese/English)\n- result: Operation result (query returns structured list/dict, start/stop returns command log)\n- target: Execution target (fixed 127.0.0.1)\n- proc_actions: Executed action list" } } } \ No newline at end of file