From 063681a1ade8e0ba85361b4846740b10960829d1 Mon Sep 17 00:00:00 2001 From: YukiRa1n <167516635+YukiRa1n@users.noreply.github.com> Date: Sun, 1 Feb 2026 02:06:50 +0800 Subject: [PATCH 01/39] feat(platform): add CLI platform adapter for testing - Add CLI platform adapter with Unix socket mode - Support isolated sessions with configurable TTL - Add whitelist exemption for CLI platform - Include astrbot-cli command-line tool - Support independent configuration file system --- astrbot-cli | 154 ++++ .../core/pipeline/whitelist_check/stage.py | 4 + astrbot/core/platform/manager.py | 4 + astrbot/core/platform/sources/cli/__init__.py | 10 + .../core/platform/sources/cli/cli_adapter.py | 722 ++++++++++++++++++ .../core/platform/sources/cli/cli_event.py | 115 +++ 6 files changed, 1009 insertions(+) create mode 100644 astrbot-cli create mode 100644 astrbot/core/platform/sources/cli/__init__.py create mode 100644 astrbot/core/platform/sources/cli/cli_adapter.py create mode 100644 astrbot/core/platform/sources/cli/cli_event.py diff --git a/astrbot-cli b/astrbot-cli new file mode 100644 index 0000000000..6c5a647710 --- /dev/null +++ b/astrbot-cli @@ -0,0 +1,154 @@ +#!/usr/bin/env python3 +""" +AstrBot CLI Tool - Unix Socket客户端 + +用法: + astrbot-cli "你好" + astrbot-cli "/help" + echo "你好" | astrbot-cli +""" + +import argparse +import json +import socket +import sys +import uuid + + +def send_message(message: str, socket_path: str = "/tmp/astrbot.sock", timeout: float = 30.0) -> dict: + """发送消息到AstrBot并获取响应 + + Args: + message: 要发送的消息 + socket_path: Unix socket路径 + timeout: 超时时间（秒） + + Returns: + 响应字典 + """ + # 创建请求 + request = { + "message": message, + "request_id": str(uuid.uuid4()) + } + + # 连接到Unix socket + try: + client_socket = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM) + client_socket.settimeout(timeout) + client_socket.connect(socket_path) + except FileNotFoundError: + return { + "status": "error", + "error": f"Socket file not found: {socket_path}. Is AstrBot running?" + } + except ConnectionRefusedError: + return { + "status": "error", + "error": "Connection refused. Is AstrBot running in socket mode?" + } + except Exception as e: + return { + "status": "error", + "error": f"Connection error: {e}" + } + + try: + # 发送请求 + request_data = json.dumps(request, ensure_ascii=False).encode('utf-8') + client_socket.sendall(request_data) + + # 接收响应 + response_data = client_socket.recv(4096) + response = json.loads(response_data.decode('utf-8')) + + return response + + except socket.timeout: + return { + "status": "error", + "error": "Request timeout" + } + except Exception as e: + return { + "status": "error", + "error": f"Communication error: {e}" + } + finally: + client_socket.close() + + +def main(): + """主函数""" + parser = argparse.ArgumentParser( + description="AstrBot CLI Tool - Send messages to AstrBot via Unix Socket", + formatter_class=argparse.RawDescriptionHelpFormatter, + epilog=""" +Examples: + astrbot-cli "你好" + astrbot-cli "/help" + astrbot-cli --socket /tmp/custom.sock "测试消息" + echo "你好" | astrbot-cli + """ + ) + + parser.add_argument( + "message", + nargs="?", + help="Message to send (if not provided, read from stdin)" + ) + + parser.add_argument( + "-s", "--socket", + default="/tmp/astrbot.sock", + help="Unix socket path (default: /tmp/astrbot.sock)" + ) + + parser.add_argument( + "-t", "--timeout", + type=float, + default=30.0, + help="Timeout in seconds (default: 30.0)" + ) + + parser.add_argument( + "-j", "--json", + action="store_true", + help="Output raw JSON response" + ) + + args = parser.parse_args() + + # 获取消息内容 + if args.message: + message = args.message + elif not sys.stdin.isatty(): + # 从stdin读取 + message = sys.stdin.read().strip() + else: + parser.print_help() + sys.exit(1) + + if not message: + print("Error: Empty message", file=sys.stderr) + sys.exit(1) + + # 发送消息 + response = send_message(message, args.socket, args.timeout) + + # 输出响应 + if args.json: + # 输出原始JSON + print(json.dumps(response, ensure_ascii=False, indent=2)) + else: + # 格式化输出 + if response.get("status") == "success": + print(response.get("response", "")) + else: + error = response.get("error", "Unknown error") + print(f"Error: {error}", file=sys.stderr) + sys.exit(1) + + +if __name__ == "__main__": + main() diff --git a/astrbot/core/pipeline/whitelist_check/stage.py b/astrbot/core/pipeline/whitelist_check/stage.py index ea9c55228e..8e66da921f 100644 --- a/astrbot/core/pipeline/whitelist_check/stage.py +++ b/astrbot/core/pipeline/whitelist_check/stage.py @@ -44,6 +44,10 @@ async def process( # WebChat 豁免 return + if event.get_platform_name() == "cli": + # CLI 平台豁免（用于测试） + return + # 检查是否在白名单 if self.wl_ignore_admin_on_group: if ( diff --git a/astrbot/core/platform/manager.py b/astrbot/core/platform/manager.py index 0238779dad..dc29665000 100644 --- a/astrbot/core/platform/manager.py +++ b/astrbot/core/platform/manager.py @@ -180,6 +180,10 @@ async def load_platform(self, platform_config: dict) -> None: from .sources.line.line_adapter import ( LinePlatformAdapter, # noqa: F401 ) + case "cli": + from .sources.cli.cli_adapter import ( + CLIPlatformAdapter, # noqa: F401 + ) except (ImportError, ModuleNotFoundError) as e: logger.error( f"加载平台适配器 {platform_config['type']} 失败，原因：{e}。请检查依赖库是否安装。提示：可以在 管理面板->平台日志->安装Pip库 中安装依赖库。", diff --git a/astrbot/core/platform/sources/cli/__init__.py b/astrbot/core/platform/sources/cli/__init__.py new file mode 100644 index 0000000000..1c087f0069 --- /dev/null +++ b/astrbot/core/platform/sources/cli/__init__.py @@ -0,0 +1,10 @@ +""" +CLI Platform Adapter Module + +命令行模拟器平台适配器，用于快速测试AstrBot插件。 +""" + +from .cli_adapter import CLIPlatformAdapter +from .cli_event import CLIMessageEvent + +__all__ = ["CLIPlatformAdapter", "CLIMessageEvent"] diff --git a/astrbot/core/platform/sources/cli/cli_adapter.py b/astrbot/core/platform/sources/cli/cli_adapter.py new file mode 100644 index 0000000000..4489482122 --- /dev/null +++ b/astrbot/core/platform/sources/cli/cli_adapter.py @@ -0,0 +1,722 @@ +""" +CLI Platform Adapter - 命令行模拟器 + +用于快速测试AstrBot插件，无需连接真实的IM平台。 +遵循Unix哲学：原子化模块、显式I/O、管道编排。 +""" + +import asyncio +import sys +import uuid +from collections.abc import Awaitable +from typing import Any + +from astrbot import logger +from astrbot.core.message.components import Plain +from astrbot.core.message.message_event_result import MessageChain +from astrbot.core.platform import ( + AstrBotMessage, + MessageMember, + MessageType, + Platform, + PlatformMetadata, +) +from astrbot.core.platform.astr_message_event import MessageSesion + +from ...register import register_platform_adapter +from .cli_event import CLIMessageEvent + + +@register_platform_adapter( + "cli", + "命令行模拟器，用于快速测试插件功能，无需连接真实IM平台", + default_config_tmpl={ + "type": "cli", + "enable": True, # 默认启用 + "mode": "socket", # 默认使用Socket模式 + "socket_path": "/tmp/astrbot.sock", + "whitelist": [], # 空白名单表示允许所有 + "use_isolated_sessions": False, # 是否启用会话隔离（每个请求独立会话） + "session_ttl": 30 # 会话过期时间（秒），仅在use_isolated_sessions=True时生效，测试用30秒，生产建议1800秒（30分钟） + }, + support_streaming_message=False, +) +class CLIPlatformAdapter(Platform): + """CLI平台适配器 + + 提供命令行交互界面，模拟消息收发流程。 + + 数据流管道: + 用户输入 → convert_input → AstrBotMessage → handle_msg → commit_event + """ + + def __init__( + self, + platform_config: dict, + platform_settings: dict, + event_queue: asyncio.Queue, + ) -> None: + """初始化CLI平台适配器 + + Args: + platform_config: 平台配置 + platform_settings: 平台设置 + event_queue: 事件队列 + """ + super().__init__(platform_config, event_queue) + + # 尝试从独立配置文件加载CLI配置 + import json + import os + config_file = platform_config.get('config_file', 'cli_config.json') + cli_config_path = f"/AstrBot/data/{config_file}" + if os.path.exists(cli_config_path): + try: + with open(cli_config_path, 'r', encoding='utf-8') as f: + cli_config = json.load(f) + # 使用独立配置文件中的配置覆盖传入的参数 + if "platform_config" in cli_config: + platform_config.update(cli_config["platform_config"]) + if "platform_settings" in cli_config: + platform_settings = cli_config["platform_settings"] + logger.info("[PROCESS] Loaded CLI config from %s", cli_config_path) + except Exception as e: + logger.warning("[WARN] Failed to load CLI config from %s: %s", cli_config_path, e) + + logger.info("[ENTRY] CLIPlatformAdapter.__init__ inputs={config=%s}", platform_config) + + self.settings = platform_settings + self.session_id = "cli_session" + self.user_id = "cli_user" + self.user_nickname = "CLI User" + + # 运行模式配置 + self.mode = platform_config.get("mode", "auto") # "auto", "tty", "file", "socket" + + # 文件I/O配置 + self.input_file = platform_config.get("input_file", "/tmp/astrbot_cli/input.txt") + self.output_file = platform_config.get("output_file", "/tmp/astrbot_cli/output.txt") + self.poll_interval = platform_config.get("poll_interval", 1.0) + + # Unix Socket配置 + self.socket_path = platform_config.get("socket_path", "/tmp/astrbot.sock") + + # 会话隔离配置 + self.use_isolated_sessions = platform_config.get("use_isolated_sessions", False) + self.session_ttl = platform_config.get("session_ttl", 30) # 默认30秒（测试），生产建议1800秒 + + self.metadata = PlatformMetadata( + name="cli", + description="命令行模拟器", + id=platform_config.get("id", "cli"), + support_streaming_message=False, + ) + + self._running = False + self._output_queue: asyncio.Queue = asyncio.Queue() + + # 会话过期跟踪（仅在use_isolated_sessions=True时使用） + self._session_timestamps: dict[str, float] = {} # {session_id: timestamp} + self._cleanup_task: asyncio.Task | None = None + + logger.info("[EXIT] CLIPlatformAdapter.__init__ return=None") + + def run(self) -> Awaitable[Any]: + """启动CLI平台 + + Returns: + 协程对象，用于异步运行 + """ + logger.info("[ENTRY] CLIPlatformAdapter.run inputs={}") + return self._run_loop() + + async def _run_loop(self) -> None: + """主运行循环 + + 管道流程: + 1. 读取用户输入 (InputReader) + 2. 转换为消息对象 (MessageConverter) + 3. 处理消息事件 (EventHandler) + 4. 输出响应 (OutputWriter) + """ + logger.info("[PROCESS] Starting CLI loop") + + # 启动会话清理任务（仅在use_isolated_sessions=True时） + if self.use_isolated_sessions: + self._cleanup_task = asyncio.create_task(self._cleanup_expired_sessions()) + logger.info("[PROCESS] Session cleanup task started") + + # 决定运行模式 + has_tty = sys.stdin.isatty() + + # Socket模式优先 + if self.mode == "socket": + logger.info("[PROCESS] Starting Unix Socket mode") + await self._run_socket_mode() + return + + # 其他模式 + if self.mode == "auto": + # 自动模式：有TTY用交互，无TTY用文件 + use_file_mode = not has_tty + elif self.mode == "file": + use_file_mode = True + elif self.mode == "tty": + use_file_mode = False + if not has_tty: + logger.warning( + "[PROCESS] TTY mode requested but no TTY detected. " + "CLI platform will not start." + ) + return + else: + logger.error(f"[ERROR] Unknown mode: {self.mode}") + return + + if use_file_mode: + logger.info("[PROCESS] Starting file polling mode") + await self._run_file_mode() + else: + logger.info("[PROCESS] Starting TTY interactive mode") + await self._run_tty_mode() + + async def _run_tty_mode(self) -> None: + """TTY交互模式""" + self._running = True + + print("\n" + "="*60) + print("AstrBot CLI Simulator") + print("="*60) + print("Type your message and press Enter to send.") + print("Type 'exit' or 'quit' to stop.") + print("="*60 + "\n") + + # 启动输出监听器 + output_task = asyncio.create_task(self._output_monitor("tty")) + + try: + while self._running: + # [原子模块1] InputReader: 读取用户输入 + user_input = await self._read_input() + + if not user_input: + continue + + # 处理退出命令 + if user_input.lower() in ["exit", "quit"]: + logger.info("[PROCESS] User requested exit") + break + + # [原子模块2] MessageConverter: 转换为AstrBotMessage + message = self._convert_input(user_input) + + # [原子模块3] EventHandler: 处理消息 + await self._handle_msg(message) + + except KeyboardInterrupt: + logger.info("[PROCESS] Received KeyboardInterrupt") + finally: + self._running = False + output_task.cancel() + logger.info("[EXIT] CLIPlatformAdapter._run_tty_mode return=None") + + async def _run_file_mode(self) -> None: + """文件轮询模式""" + import os + import time + + self._running = True + + # 确保目录存在 + os.makedirs(os.path.dirname(self.input_file), exist_ok=True) + os.makedirs(os.path.dirname(self.output_file), exist_ok=True) + + # 创建输入文件（如果不存在） + if not os.path.exists(self.input_file): + with open(self.input_file, 'w') as f: + f.write("") + + logger.info(f"[PROCESS] File mode started") + logger.info(f"[PROCESS] Input file: {self.input_file}") + logger.info(f"[PROCESS] Output file: {self.output_file}") + logger.info(f"[PROCESS] Poll interval: {self.poll_interval}s") + + # 启动输出监听器 + output_task = asyncio.create_task(self._output_monitor("file")) + + try: + while self._running: + # 读取输入文件 + commands = await self._read_from_file() + + for cmd in commands: + if not cmd: + continue + + logger.info(f"[PROCESS] Processing command: {cmd}") + + # 转换并处理消息 + message = self._convert_input(cmd) + await self._handle_msg(message) + + # 等待下一次轮询 + await asyncio.sleep(self.poll_interval) + + except Exception as e: + logger.error(f"[ERROR] File mode error: {e}") + finally: + self._running = False + output_task.cancel() + logger.info("[EXIT] CLIPlatformAdapter._run_file_mode return=None") + + async def _run_socket_mode(self) -> None: + """Unix Socket服务器模式 + + 管道流程: + 客户端连接 → 接收JSON请求 → 解析消息 → 创建事件 → 等待响应 → 返回JSON + """ + import os + import socket + import json + + self._running = True + + # 删除旧的socket文件 + if os.path.exists(self.socket_path): + os.remove(self.socket_path) + logger.info(f"[PROCESS] Removed old socket file: {self.socket_path}") + + # 创建Unix socket + server_socket = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM) + server_socket.bind(self.socket_path) + server_socket.listen(5) + server_socket.setblocking(False) + + logger.info(f"[PROCESS] Unix Socket server started: {self.socket_path}") + + try: + while self._running: + try: + # 接受连接（非阻塞） + loop = asyncio.get_event_loop() + client_socket, _ = await loop.sock_accept(server_socket) + + # 处理连接（异步） + asyncio.create_task(self._handle_socket_client(client_socket)) + + except Exception as e: + logger.error(f"[ERROR] Socket accept error: {e}") + await asyncio.sleep(0.1) + + except Exception as e: + logger.error(f"[ERROR] Socket mode error: {e}") + finally: + self._running = False + server_socket.close() + if os.path.exists(self.socket_path): + os.remove(self.socket_path) + logger.info("[EXIT] CLIPlatformAdapter._run_socket_mode return=None") + + async def _handle_socket_client(self, client_socket) -> None: + """[原子模块] SocketHandler: 处理单个socket客户端连接 + + I/O契约: + Input: socket连接 + Output: None (发送JSON响应到客户端) + """ + import json + + logger.debug("[ENTRY] _handle_socket_client") + + try: + loop = asyncio.get_event_loop() + + # 接收请求数据 + data = await loop.sock_recv(client_socket, 4096) + if not data: + logger.debug("[PROCESS] Empty request, closing connection") + return + + # 解析JSON请求 + try: + request = json.loads(data.decode('utf-8')) + message_text = request.get('message', '') + request_id = request.get('request_id', str(uuid.uuid4())) + + logger.info(f"[PROCESS] Received socket request: {message_text[:50]}...") + + except json.JSONDecodeError as e: + logger.error(f"[ERROR] Invalid JSON request: {e}") + error_response = json.dumps({ + 'status': 'error', + 'error': 'Invalid JSON format' + }) + await loop.sock_sendall(client_socket, error_response.encode('utf-8')) + return + + # 创建响应Future + response_future = asyncio.Future() + + # 转换并处理消息（传递request_id实现会话隔离） + message = self._convert_input(message_text, request_id=request_id) + + # 创建带response_future的事件 + message_event = CLIMessageEvent( + message_str=message.message_str, + message_obj=message, + platform_meta=self.meta(), + session_id=message.session_id, + output_queue=self._output_queue, + response_future=response_future, + ) + + # 提交事件 + self.commit_event(message_event) + + # 等待响应（超时30秒） + try: + message_chain = await asyncio.wait_for(response_future, timeout=30.0) + + # 提取文本 + response_text = message_chain.get_plain_text() + + # 提取图片 + from astrbot.core.message.components import Image + images = [] + for comp in message_chain.chain: + if isinstance(comp, Image): + image_info = {} + if comp.file: + if comp.file.startswith("http"): + image_info["type"] = "url" + image_info["url"] = comp.file + elif comp.file.startswith("file:///"): + image_info["type"] = "file" + file_path = comp.file[8:] # 去掉 file:/// + image_info["path"] = file_path + + # 立即读取文件内容并转换为base64（避免临时文件被删除） + try: + import base64 + with open(file_path, 'rb') as f: + image_data = f.read() + base64_data = base64.b64encode(image_data).decode('utf-8') + image_info["base64_data"] = base64_data + image_info["size"] = len(image_data) + logger.debug(f"[PROCESS] Read image file: {file_path}, size: {len(image_data)} bytes") + except Exception as e: + logger.error(f"[ERROR] Failed to read image file {file_path}: {e}") + image_info["error"] = str(e) + elif comp.file.startswith("base64://"): + image_info["type"] = "base64" + # 返回完整的base64数据 + base64_data = comp.file[9:] + image_info["base64_data"] = base64_data + image_info["base64_length"] = len(base64_data) + images.append(image_info) + + # 发送成功响应 + response = json.dumps({ + 'status': 'success', + 'response': response_text, + 'images': images, + 'request_id': request_id + }, ensure_ascii=False) + + await loop.sock_sendall(client_socket, response.encode('utf-8')) + logger.info(f"[PROCESS] Sent response for request {request_id}") + + except asyncio.TimeoutError: + logger.error(f"[ERROR] Request {request_id} timeout") + error_response = json.dumps({ + 'status': 'error', + 'error': 'Request timeout', + 'request_id': request_id + }) + await loop.sock_sendall(client_socket, error_response.encode('utf-8')) + + except Exception as e: + logger.error(f"[ERROR] Socket client handler error: {e}") + import traceback + logger.error(traceback.format_exc()) + + finally: + client_socket.close() + logger.debug("[EXIT] _handle_socket_client return=None") + + async def _read_input(self) -> str: + """[原子模块] InputReader: 从命令行读取用户输入 + + I/O契约: + Input: None + Output: str (用户输入的文本) + """ + logger.debug("[ENTRY] _read_input inputs={}") + + # 使用asyncio在事件循环中运行阻塞的input() + loop = asyncio.get_event_loop() + user_input = await loop.run_in_executor(None, input, "You: ") + + logger.debug("[EXIT] _read_input return={input=%s}", user_input) + return user_input.strip() + + async def _read_from_file(self) -> list[str]: + """[原子模块] FileReader: 从文件读取命令 + + I/O契约: + Input: None + Output: list[str] (命令列表) + """ + import os + + try: + if not os.path.exists(self.input_file): + return [] + + # 读取文件内容 + with open(self.input_file, 'r', encoding='utf-8') as f: + content = f.read().strip() + + if not content: + return [] + + # 按行分割命令 + commands = [line.strip() for line in content.split('\n') if line.strip()] + + # 清空输入文件 + with open(self.input_file, 'w', encoding='utf-8') as f: + f.write("") + + logger.debug(f"[EXIT] _read_from_file return={len(commands)} commands") + return commands + + except Exception as e: + logger.error(f"[ERROR] Failed to read from file: {e}") + return [] + + def _convert_input(self, text: str, request_id: str = None) -> AstrBotMessage: + """[原子模块] MessageConverter: 将文本转换为AstrBotMessage + + I/O契约: + Input: str (原始文本), request_id (可选，用于会话隔离) + Output: AstrBotMessage (标准消息对象) + """ + logger.debug("[ENTRY] _convert_input inputs={text=%s, request_id=%s}", text, request_id) + + message = AstrBotMessage() + message.self_id = "cli_bot" + message.message_str = text + message.message = [Plain(text)] # 使用Plain组件对象，而不是字典 + message.type = MessageType.FRIEND_MESSAGE + + # 添加message_id属性，避免插件访问时出错 + import uuid + message.message_id = str(uuid.uuid4()) + + # 根据配置决定是否使用会话隔离 + if self.use_isolated_sessions and request_id: + # 启用会话隔离：每个请求独立会话 + session_id = f"cli_session_{request_id}" + message.session_id = session_id + + # 记录会话创建时间（用于过期清理） + import time + if session_id not in self._session_timestamps: + self._session_timestamps[session_id] = time.time() + logger.debug(f"[PROCESS] Created isolated session: {session_id}, TTL={self.session_ttl}s") + else: + # 默认模式：使用固定会话ID + message.session_id = self.session_id + + message.sender = MessageMember( + user_id=self.user_id, + nickname=self.user_nickname, + ) + + logger.debug("[EXIT] _convert_input return={message=%s}", message) + return message + + async def _handle_msg(self, message: AstrBotMessage) -> None: + """[原子模块] EventHandler: 处理消息并提交事件 + + I/O契约: + Input: AstrBotMessage + Output: None (提交到事件队列) + """ + logger.debug("[ENTRY] _handle_msg inputs={message=%s}", message.message_str) + + # 创建消息事件 + message_event = CLIMessageEvent( + message_str=message.message_str, + message_obj=message, + platform_meta=self.meta(), + session_id=message.session_id, + output_queue=self._output_queue, + ) + + logger.info("[PROCESS] Committing event to queue: session_id=%s", message.session_id) + + # 提交到事件队列 + self.commit_event(message_event) + + logger.debug("[EXIT] _handle_msg return=None") + + async def _output_monitor(self, mode: str = "tty") -> None: + """[原子模块] ResponseMonitor: 监听响应队列并输出 + + I/O契约: + Input: MessageChain (从响应队列) + Output: None (输出到stdout或文件) + + Args: + mode: 输出模式，"tty"或"file" + """ + logger.debug(f"[ENTRY] _output_monitor inputs={{mode={mode}}}") + + while self._running: + try: + # 从输出队列获取响应 + message_chain = await asyncio.wait_for( + self._output_queue.get(), + timeout=0.5 + ) + + # 根据模式选择输出方式 + if mode == "file": + await self._write_to_file(message_chain) + else: + self._write_output(message_chain) + + except asyncio.TimeoutError: + continue + except Exception as e: + logger.error("[ERROR] Output monitor error: %s", e) + + logger.debug("[EXIT] _output_monitor return=None") + + def _write_output(self, message_chain: MessageChain) -> None: + """[原子模块] OutputWriter: 将消息输出到命令行 + + I/O契约: + Input: MessageChain + Output: None (打印到stdout) + """ + logger.debug("[ENTRY] _write_output inputs={message_chain=%s}", message_chain) + + print(f"\nBot: {message_chain.get_plain_text()}\n") + + logger.debug("[EXIT] _write_output return=None") + + async def _write_to_file(self, message_chain: MessageChain) -> None: + """[原子模块] FileWriter: 将消息输出到文件 + + I/O契约: + Input: MessageChain + Output: None (写入文件) + """ + import datetime + + logger.debug("[ENTRY] _write_to_file inputs={message_chain=%s}", message_chain) + + try: + # 获取消息文本 + text = message_chain.get_plain_text() + + # 添加时间戳 + timestamp = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S") + output_line = f"[{timestamp}] Bot: {text}\n" + + # 追加到输出文件 + with open(self.output_file, 'a', encoding='utf-8') as f: + f.write(output_line) + + logger.info(f"[PROCESS] Output written to file: {self.output_file}") + + except Exception as e: + logger.error(f"[ERROR] Failed to write to file: {e}") + + logger.debug("[EXIT] _write_to_file return=None") + + async def send_by_session( + self, + session: MessageSesion, + message_chain: MessageChain, + ) -> None: + """通过会话发送消息 + + Args: + session: 消息会话 + message_chain: 消息链 + """ + logger.debug("[ENTRY] send_by_session inputs={session=%s}", session) + + # 将消息放入输出队列 + await self._output_queue.put(message_chain) + + await super().send_by_session(session, message_chain) + + logger.debug("[EXIT] send_by_session return=None") + + def meta(self) -> PlatformMetadata: + """获取平台元数据 + + Returns: + 平台元数据 + """ + return self.metadata + + async def _cleanup_expired_sessions(self) -> None: + """[后台任务] 定期清理过期的会话记录 + + 仅在use_isolated_sessions=True时运行。 + 定期检查_session_timestamps，删除过期的会话记录。 + """ + import time + + logger.info("[ENTRY] _cleanup_expired_sessions started, TTL=%s seconds", self.session_ttl) + + while self._running: + try: + await asyncio.sleep(10) # 每10秒检查一次 + + if not self.use_isolated_sessions: + continue + + current_time = time.time() + expired_sessions = [] + + # 找出过期的会话 + for session_id, timestamp in list(self._session_timestamps.items()): + if current_time - timestamp > self.session_ttl: + expired_sessions.append(session_id) + + # 清理过期会话 + for session_id in expired_sessions: + logger.info(f"[PROCESS] Cleaning expired session: {session_id}") + self._session_timestamps.pop(session_id, None) + + # TODO: 从数据库删除会话记录（如果需要） + # await self.context.db.delete_platform_session(session_id) + + if expired_sessions: + logger.info(f"[PROCESS] Cleaned {len(expired_sessions)} expired sessions") + + except Exception as e: + logger.error(f"[ERROR] Session cleanup error: {e}") + + logger.info("[EXIT] _cleanup_expired_sessions stopped") + + async def terminate(self) -> None: + """终止平台运行""" + logger.info("[ENTRY] CLIPlatformAdapter.terminate inputs={}") + self._running = False + + # 停止清理任务 + if self._cleanup_task and not self._cleanup_task.done(): + self._cleanup_task.cancel() + try: + await self._cleanup_task + except asyncio.CancelledError: + logger.info("[PROCESS] Cleanup task cancelled") + + logger.info("[EXIT] CLIPlatformAdapter.terminate return=None") diff --git a/astrbot/core/platform/sources/cli/cli_event.py b/astrbot/core/platform/sources/cli/cli_event.py new file mode 100644 index 0000000000..3bb7d28057 --- /dev/null +++ b/astrbot/core/platform/sources/cli/cli_event.py @@ -0,0 +1,115 @@ +""" +CLI Message Event - CLI消息事件 + +处理CLI平台的消息事件，包括消息发送和接收。 +""" + +import asyncio +from typing import Any + +from astrbot import logger +from astrbot.core.message.components import Plain +from astrbot.core.message.message_event_result import MessageChain +from astrbot.core.platform.astr_message_event import AstrMessageEvent +from astrbot.core.platform.astrbot_message import AstrBotMessage +from astrbot.core.platform.platform_metadata import PlatformMetadata + + +class CLIMessageEvent(AstrMessageEvent): + """CLI消息事件 + + 处理命令行模拟器的消息事件。 + """ + + def __init__( + self, + message_str: str, + message_obj: AstrBotMessage, + platform_meta: PlatformMetadata, + session_id: str, + output_queue: asyncio.Queue, + response_future: asyncio.Future = None, + ): + """初始化CLI消息事件 + + Args: + message_str: 纯文本消息 + message_obj: 消息对象 + platform_meta: 平台元数据 + session_id: 会话ID + output_queue: 输出队列 + response_future: 响应Future对象（用于socket模式） + """ + super().__init__( + message_str=message_str, + message_obj=message_obj, + platform_meta=platform_meta, + session_id=session_id, + ) + + logger.debug("[ENTRY] CLIMessageEvent.__init__ inputs={message_str=%s}", message_str) + + self.output_queue = output_queue + self.response_future = response_future + + logger.debug("[EXIT] CLIMessageEvent.__init__ return=None") + + async def send(self, message_chain: MessageChain) -> dict[str, Any]: + """发送消息到CLI + + Args: + message_chain: 消息链 + + Returns: + 发送结果 + """ + logger.debug("[ENTRY] CLIMessageEvent.send inputs={message_chain=%s}", message_chain) + + # Socket模式：直接设置Future结果（返回完整MessageChain以支持图片等组件） + if self.response_future is not None and not self.response_future.done(): + # 预处理本地文件图片：立即读取并转换为base64（避免临时文件被删除） + from astrbot.core.message.components import Image + import base64 + import os + + for comp in message_chain.chain: + if isinstance(comp, Image) and comp.file and comp.file.startswith("file:///"): + file_path = comp.file[8:] # 去掉 file:/// + try: + if os.path.exists(file_path): + with open(file_path, 'rb') as f: + image_data = f.read() + base64_data = base64.b64encode(image_data).decode('utf-8') + # 修改Image组件，将本地文件转换为base64 + comp.file = f"base64://{base64_data}" + logger.debug(f"[PROCESS] Converted local image to base64: {file_path}, size: {len(image_data)} bytes") + except Exception as e: + logger.error(f"[ERROR] Failed to read image file {file_path}: {e}") + + self.response_future.set_result(message_chain) + logger.debug("[PROCESS] Set socket response future with MessageChain") + else: + # 其他模式：将消息放入输出队列 + await self.output_queue.put(message_chain) + logger.debug("[PROCESS] Put message to output queue") + + logger.debug("[EXIT] CLIMessageEvent.send return={success=True}") + + return {"success": True} + + async def reply(self, message_chain: MessageChain) -> dict[str, Any]: + """回复消息 + + Args: + message_chain: 消息链 + + Returns: + 发送结果 + """ + logger.debug("[ENTRY] CLIMessageEvent.reply inputs={message_chain=%s}", message_chain) + + result = await self.send(message_chain) + + logger.debug("[EXIT] CLIMessageEvent.reply return=%s", result) + + return result From ec4ca74c4e0f206869b0dc6abd11d45cd3eed830 Mon Sep 17 00:00:00 2001 From: YukiRa1n <167516635+YukiRa1n@users.noreply.github.com> Date: Sun, 1 Feb 2026 02:19:14 +0800 Subject: [PATCH 02/39] refactor(platform): rename CLI adapter to CLI Tester and disable by default - Rename "CLI Platform Adapter" to "CLI Tester" - Set default enable to false (disabled by default) - Update descriptions to emphasize testing and debugging purpose - Clarify design goal: build fast feedback loop for vibe coding --- astrbot/core/platform/sources/cli/cli_adapter.py | 13 +++++++------ 1 file changed, 7 insertions(+), 6 deletions(-) diff --git a/astrbot/core/platform/sources/cli/cli_adapter.py b/astrbot/core/platform/sources/cli/cli_adapter.py index 4489482122..ac67238b03 100644 --- a/astrbot/core/platform/sources/cli/cli_adapter.py +++ b/astrbot/core/platform/sources/cli/cli_adapter.py @@ -1,7 +1,8 @@ """ -CLI Platform Adapter - 命令行模拟器 +CLI Tester - CLI测试器 -用于快速测试AstrBot插件，无需连接真实的IM平台。 +用于快速测试和调试AstrBot插件，无需连接真实的IM平台。 +构建快速反馈循环，支持Vibe Coding开发模式。 遵循Unix哲学：原子化模块、显式I/O、管道编排。 """ @@ -29,10 +30,10 @@ @register_platform_adapter( "cli", - "命令行模拟器，用于快速测试插件功能，无需连接真实IM平台", + "CLI测试器，用于快速测试和调试插件，构建快速反馈循环", default_config_tmpl={ "type": "cli", - "enable": True, # 默认启用 + "enable": False, # 默认关闭，开发时手动启用 "mode": "socket", # 默认使用Socket模式 "socket_path": "/tmp/astrbot.sock", "whitelist": [], # 空白名单表示允许所有 @@ -42,9 +43,9 @@ support_streaming_message=False, ) class CLIPlatformAdapter(Platform): - """CLI平台适配器 + """CLI测试器 - 提供命令行交互界面，模拟消息收发流程。 + 提供命令行交互界面，用于快速测试和调试插件。 数据流管道: 用户输入 → convert_input → AstrBotMessage → handle_msg → commit_event From 5f549acde84eb13337169ca2f454a2c8a81a9b60 Mon Sep 17 00:00:00 2001 From: YukiRa1n <167516635+YukiRa1n@users.noreply.github.com> Date: Sun, 1 Feb 2026 03:07:40 +0800 Subject: [PATCH 03/39] feat: add token-based authentication for CLI platform - Implement automatic token generation on first startup - Add token validation in socket handler - Add token loading and sending in CLI client - Set token file permissions to 600 - Add security logging for rejected requests Token file: /AstrBot/data/.cli_token Algorithm: secrets.token_urlsafe(32) --- astrbot-cli | 77 +++--- .../core/platform/sources/cli/cli_adapter.py | 228 +++++++++++++----- 2 files changed, 218 insertions(+), 87 deletions(-) diff --git a/astrbot-cli b/astrbot-cli index 6c5a647710..e065801d29 100644 --- a/astrbot-cli +++ b/astrbot-cli @@ -15,7 +15,25 @@ import sys import uuid -def send_message(message: str, socket_path: str = "/tmp/astrbot.sock", timeout: float = 30.0) -> dict: +def load_auth_token() -> str: + """从密钥文件加载认证token + + Returns: + token字符串,如果文件不存在则返回空字符串 + """ + token_file = "/AstrBot/data/.cli_token" + try: + with open(token_file, encoding="utf-8") as f: + return f.read().strip() + except FileNotFoundError: + return "" + except Exception: + return "" + + +def send_message( + message: str, socket_path: str = "/tmp/astrbot.sock", timeout: float = 30.0 +) -> dict: """发送消息到AstrBot并获取响应 Args: @@ -26,11 +44,15 @@ def send_message(message: str, socket_path: str = "/tmp/astrbot.sock", timeout: Returns: 响应字典 """ + # 加载认证token + auth_token = load_auth_token() + # 创建请求 - request = { - "message": message, - "request_id": str(uuid.uuid4()) - } + request = {"message": message, "request_id": str(uuid.uuid4())} + + # 如果token存在,添加到请求中 + if auth_token: + request["auth_token"] = auth_token # 连接到Unix socket try: @@ -40,40 +62,31 @@ def send_message(message: str, socket_path: str = "/tmp/astrbot.sock", timeout: except FileNotFoundError: return { "status": "error", - "error": f"Socket file not found: {socket_path}. Is AstrBot running?" + "error": f"Socket file not found: {socket_path}. Is AstrBot running?", } except ConnectionRefusedError: return { "status": "error", - "error": "Connection refused. Is AstrBot running in socket mode?" + "error": "Connection refused. Is AstrBot running in socket mode?", } except Exception as e: - return { - "status": "error", - "error": f"Connection error: {e}" - } + return {"status": "error", "error": f"Connection error: {e}"} try: # 发送请求 - request_data = json.dumps(request, ensure_ascii=False).encode('utf-8') + request_data = json.dumps(request, ensure_ascii=False).encode("utf-8") client_socket.sendall(request_data) # 接收响应 response_data = client_socket.recv(4096) - response = json.loads(response_data.decode('utf-8')) + response = json.loads(response_data.decode("utf-8")) return response - except socket.timeout: - return { - "status": "error", - "error": "Request timeout" - } + except TimeoutError: + return {"status": "error", "error": "Request timeout"} except Exception as e: - return { - "status": "error", - "error": f"Communication error: {e}" - } + return {"status": "error", "error": f"Communication error: {e}"} finally: client_socket.close() @@ -89,32 +102,30 @@ Examples: astrbot-cli "/help" astrbot-cli --socket /tmp/custom.sock "测试消息" echo "你好" | astrbot-cli - """ + """, ) parser.add_argument( - "message", - nargs="?", - help="Message to send (if not provided, read from stdin)" + "message", nargs="?", help="Message to send (if not provided, read from stdin)" ) parser.add_argument( - "-s", "--socket", + "-s", + "--socket", default="/tmp/astrbot.sock", - help="Unix socket path (default: /tmp/astrbot.sock)" + help="Unix socket path (default: /tmp/astrbot.sock)", ) parser.add_argument( - "-t", "--timeout", + "-t", + "--timeout", type=float, default=30.0, - help="Timeout in seconds (default: 30.0)" + help="Timeout in seconds (default: 30.0)", ) parser.add_argument( - "-j", "--json", - action="store_true", - help="Output raw JSON response" + "-j", "--json", action="store_true", help="Output raw JSON response" ) args = parser.parse_args() diff --git a/astrbot/core/platform/sources/cli/cli_adapter.py b/astrbot/core/platform/sources/cli/cli_adapter.py index ac67238b03..79459a7781 100644 --- a/astrbot/core/platform/sources/cli/cli_adapter.py +++ b/astrbot/core/platform/sources/cli/cli_adapter.py @@ -38,7 +38,7 @@ "socket_path": "/tmp/astrbot.sock", "whitelist": [], # 空白名单表示允许所有 "use_isolated_sessions": False, # 是否启用会话隔离（每个请求独立会话） - "session_ttl": 30 # 会话过期时间（秒），仅在use_isolated_sessions=True时生效，测试用30秒，生产建议1800秒（30分钟） + "session_ttl": 30, # 会话过期时间（秒），仅在use_isolated_sessions=True时生效，测试用30秒，生产建议1800秒（30分钟） }, support_streaming_message=False, ) @@ -69,11 +69,12 @@ def __init__( # 尝试从独立配置文件加载CLI配置 import json import os - config_file = platform_config.get('config_file', 'cli_config.json') + + config_file = platform_config.get("config_file", "cli_config.json") cli_config_path = f"/AstrBot/data/{config_file}" if os.path.exists(cli_config_path): try: - with open(cli_config_path, 'r', encoding='utf-8') as f: + with open(cli_config_path, encoding="utf-8") as f: cli_config = json.load(f) # 使用独立配置文件中的配置覆盖传入的参数 if "platform_config" in cli_config: @@ -82,9 +83,13 @@ def __init__( platform_settings = cli_config["platform_settings"] logger.info("[PROCESS] Loaded CLI config from %s", cli_config_path) except Exception as e: - logger.warning("[WARN] Failed to load CLI config from %s: %s", cli_config_path, e) + logger.warning( + "[WARN] Failed to load CLI config from %s: %s", cli_config_path, e + ) - logger.info("[ENTRY] CLIPlatformAdapter.__init__ inputs={config=%s}", platform_config) + logger.info( + "[ENTRY] CLIPlatformAdapter.__init__ inputs={config=%s}", platform_config + ) self.settings = platform_settings self.session_id = "cli_session" @@ -92,19 +97,30 @@ def __init__( self.user_nickname = "CLI User" # 运行模式配置 - self.mode = platform_config.get("mode", "auto") # "auto", "tty", "file", "socket" + self.mode = platform_config.get( + "mode", "auto" + ) # "auto", "tty", "file", "socket" # 文件I/O配置 - self.input_file = platform_config.get("input_file", "/tmp/astrbot_cli/input.txt") - self.output_file = platform_config.get("output_file", "/tmp/astrbot_cli/output.txt") + self.input_file = platform_config.get( + "input_file", "/tmp/astrbot_cli/input.txt" + ) + self.output_file = platform_config.get( + "output_file", "/tmp/astrbot_cli/output.txt" + ) self.poll_interval = platform_config.get("poll_interval", 1.0) # Unix Socket配置 self.socket_path = platform_config.get("socket_path", "/tmp/astrbot.sock") + # Token认证配置 + self.auth_token = self._ensure_auth_token() + # 会话隔离配置 self.use_isolated_sessions = platform_config.get("use_isolated_sessions", False) - self.session_ttl = platform_config.get("session_ttl", 30) # 默认30秒（测试），生产建议1800秒 + self.session_ttl = platform_config.get( + "session_ttl", 30 + ) # 默认30秒（测试），生产建议1800秒 self.metadata = PlatformMetadata( name="cli", @@ -131,6 +147,57 @@ def run(self) -> Awaitable[Any]: logger.info("[ENTRY] CLIPlatformAdapter.run inputs={}") return self._run_loop() + def _ensure_auth_token(self) -> str | None: + """[原子模块] TokenManager: 确保认证token存在,不存在则自动生成 + + I/O契约: + Input: None + Output: str | None (token字符串或None) + """ + import os + import secrets + + token_file = "/AstrBot/data/.cli_token" + + logger.debug("[ENTRY] _ensure_auth_token inputs={}") + + try: + # 如果token文件已存在,直接读取 + if os.path.exists(token_file): + with open(token_file, encoding="utf-8") as f: + token = f.read().strip() + + if token: + logger.info("[SECURITY] Authentication token loaded from file") + logger.debug( + "[EXIT] _ensure_auth_token return={token_length=%d}", len(token) + ) + return token + else: + logger.warning("[SECURITY] Token file is empty, regenerating") + + # 首次启动或token为空,自动生成新token + token = secrets.token_urlsafe(32) + + # 写入文件 + with open(token_file, "w", encoding="utf-8") as f: + f.write(token) + + # 设置严格权限(仅所有者可读写) + os.chmod(token_file, 0o600) + + logger.info("[SECURITY] Generated new authentication token: %s", token) + logger.info("[SECURITY] Token saved to: %s (permissions: 600)", token_file) + logger.debug( + "[EXIT] _ensure_auth_token return={token_length=%d}", len(token) + ) + return token + + except Exception as e: + logger.error("[ERROR] Failed to ensure token: %s", e) + logger.warning("[SECURITY] Authentication disabled due to token error") + return None + async def _run_loop(self) -> None: """主运行循环 @@ -185,12 +252,12 @@ async def _run_tty_mode(self) -> None: """TTY交互模式""" self._running = True - print("\n" + "="*60) + print("\n" + "=" * 60) print("AstrBot CLI Simulator") - print("="*60) + print("=" * 60) print("Type your message and press Enter to send.") print("Type 'exit' or 'quit' to stop.") - print("="*60 + "\n") + print("=" * 60 + "\n") # 启动输出监听器 output_task = asyncio.create_task(self._output_monitor("tty")) @@ -224,7 +291,6 @@ async def _run_tty_mode(self) -> None: async def _run_file_mode(self) -> None: """文件轮询模式""" import os - import time self._running = True @@ -234,10 +300,10 @@ async def _run_file_mode(self) -> None: # 创建输入文件（如果不存在） if not os.path.exists(self.input_file): - with open(self.input_file, 'w') as f: + with open(self.input_file, "w") as f: f.write("") - logger.info(f"[PROCESS] File mode started") + logger.info("[PROCESS] File mode started") logger.info(f"[PROCESS] Input file: {self.input_file}") logger.info(f"[PROCESS] Output file: {self.output_file}") logger.info(f"[PROCESS] Poll interval: {self.poll_interval}s") @@ -278,7 +344,6 @@ async def _run_socket_mode(self) -> None: """ import os import socket - import json self._running = True @@ -340,21 +405,50 @@ async def _handle_socket_client(self, client_socket) -> None: # 解析JSON请求 try: - request = json.loads(data.decode('utf-8')) - message_text = request.get('message', '') - request_id = request.get('request_id', str(uuid.uuid4())) + request = json.loads(data.decode("utf-8")) + message_text = request.get("message", "") + request_id = request.get("request_id", str(uuid.uuid4())) + auth_token = request.get("auth_token", "") - logger.info(f"[PROCESS] Received socket request: {message_text[:50]}...") + logger.info( + f"[PROCESS] Received socket request: {message_text[:50]}..." + ) except json.JSONDecodeError as e: logger.error(f"[ERROR] Invalid JSON request: {e}") - error_response = json.dumps({ - 'status': 'error', - 'error': 'Invalid JSON format' - }) - await loop.sock_sendall(client_socket, error_response.encode('utf-8')) + error_response = json.dumps( + {"status": "error", "error": "Invalid JSON format"} + ) + await loop.sock_sendall(client_socket, error_response.encode("utf-8")) return + # Token验证 + if self.auth_token: + if not auth_token: + logger.warning("[SECURITY] Request rejected: missing auth_token") + error_response = json.dumps( + {"status": "error", "error": "Unauthorized: missing token"} + ) + await loop.sock_sendall( + client_socket, error_response.encode("utf-8") + ) + return + + if auth_token != self.auth_token: + logger.warning( + "[SECURITY] Request rejected: invalid auth_token (length=%d)", + len(auth_token), + ) + error_response = json.dumps( + {"status": "error", "error": "Unauthorized: invalid token"} + ) + await loop.sock_sendall( + client_socket, error_response.encode("utf-8") + ) + return + + logger.debug("[SECURITY] Token validation passed") + # 创建响应Future response_future = asyncio.Future() @@ -383,6 +477,7 @@ async def _handle_socket_client(self, client_socket) -> None: # 提取图片 from astrbot.core.message.components import Image + images = [] for comp in message_chain.chain: if isinstance(comp, Image): @@ -399,14 +494,21 @@ async def _handle_socket_client(self, client_socket) -> None: # 立即读取文件内容并转换为base64（避免临时文件被删除） try: import base64 - with open(file_path, 'rb') as f: + + with open(file_path, "rb") as f: image_data = f.read() - base64_data = base64.b64encode(image_data).decode('utf-8') + base64_data = base64.b64encode( + image_data + ).decode("utf-8") image_info["base64_data"] = base64_data image_info["size"] = len(image_data) - logger.debug(f"[PROCESS] Read image file: {file_path}, size: {len(image_data)} bytes") + logger.debug( + f"[PROCESS] Read image file: {file_path}, size: {len(image_data)} bytes" + ) except Exception as e: - logger.error(f"[ERROR] Failed to read image file {file_path}: {e}") + logger.error( + f"[ERROR] Failed to read image file {file_path}: {e}" + ) image_info["error"] = str(e) elif comp.file.startswith("base64://"): image_info["type"] = "base64" @@ -417,28 +519,34 @@ async def _handle_socket_client(self, client_socket) -> None: images.append(image_info) # 发送成功响应 - response = json.dumps({ - 'status': 'success', - 'response': response_text, - 'images': images, - 'request_id': request_id - }, ensure_ascii=False) - - await loop.sock_sendall(client_socket, response.encode('utf-8')) + response = json.dumps( + { + "status": "success", + "response": response_text, + "images": images, + "request_id": request_id, + }, + ensure_ascii=False, + ) + + await loop.sock_sendall(client_socket, response.encode("utf-8")) logger.info(f"[PROCESS] Sent response for request {request_id}") except asyncio.TimeoutError: logger.error(f"[ERROR] Request {request_id} timeout") - error_response = json.dumps({ - 'status': 'error', - 'error': 'Request timeout', - 'request_id': request_id - }) - await loop.sock_sendall(client_socket, error_response.encode('utf-8')) + error_response = json.dumps( + { + "status": "error", + "error": "Request timeout", + "request_id": request_id, + } + ) + await loop.sock_sendall(client_socket, error_response.encode("utf-8")) except Exception as e: logger.error(f"[ERROR] Socket client handler error: {e}") import traceback + logger.error(traceback.format_exc()) finally: @@ -475,17 +583,17 @@ async def _read_from_file(self) -> list[str]: return [] # 读取文件内容 - with open(self.input_file, 'r', encoding='utf-8') as f: + with open(self.input_file, encoding="utf-8") as f: content = f.read().strip() if not content: return [] # 按行分割命令 - commands = [line.strip() for line in content.split('\n') if line.strip()] + commands = [line.strip() for line in content.split("\n") if line.strip()] # 清空输入文件 - with open(self.input_file, 'w', encoding='utf-8') as f: + with open(self.input_file, "w", encoding="utf-8") as f: f.write("") logger.debug(f"[EXIT] _read_from_file return={len(commands)} commands") @@ -502,7 +610,9 @@ def _convert_input(self, text: str, request_id: str = None) -> AstrBotMessage: Input: str (原始文本), request_id (可选，用于会话隔离) Output: AstrBotMessage (标准消息对象) """ - logger.debug("[ENTRY] _convert_input inputs={text=%s, request_id=%s}", text, request_id) + logger.debug( + "[ENTRY] _convert_input inputs={text=%s, request_id=%s}", text, request_id + ) message = AstrBotMessage() message.self_id = "cli_bot" @@ -512,6 +622,7 @@ def _convert_input(self, text: str, request_id: str = None) -> AstrBotMessage: # 添加message_id属性，避免插件访问时出错 import uuid + message.message_id = str(uuid.uuid4()) # 根据配置决定是否使用会话隔离 @@ -522,9 +633,12 @@ def _convert_input(self, text: str, request_id: str = None) -> AstrBotMessage: # 记录会话创建时间（用于过期清理） import time + if session_id not in self._session_timestamps: self._session_timestamps[session_id] = time.time() - logger.debug(f"[PROCESS] Created isolated session: {session_id}, TTL={self.session_ttl}s") + logger.debug( + f"[PROCESS] Created isolated session: {session_id}, TTL={self.session_ttl}s" + ) else: # 默认模式：使用固定会话ID message.session_id = self.session_id @@ -555,7 +669,9 @@ async def _handle_msg(self, message: AstrBotMessage) -> None: output_queue=self._output_queue, ) - logger.info("[PROCESS] Committing event to queue: session_id=%s", message.session_id) + logger.info( + "[PROCESS] Committing event to queue: session_id=%s", message.session_id + ) # 提交到事件队列 self.commit_event(message_event) @@ -578,8 +694,7 @@ async def _output_monitor(self, mode: str = "tty") -> None: try: # 从输出队列获取响应 message_chain = await asyncio.wait_for( - self._output_queue.get(), - timeout=0.5 + self._output_queue.get(), timeout=0.5 ) # 根据模式选择输出方式 @@ -628,7 +743,7 @@ async def _write_to_file(self, message_chain: MessageChain) -> None: output_line = f"[{timestamp}] Bot: {text}\n" # 追加到输出文件 - with open(self.output_file, 'a', encoding='utf-8') as f: + with open(self.output_file, "a", encoding="utf-8") as f: f.write(output_line) logger.info(f"[PROCESS] Output written to file: {self.output_file}") @@ -674,7 +789,10 @@ async def _cleanup_expired_sessions(self) -> None: """ import time - logger.info("[ENTRY] _cleanup_expired_sessions started, TTL=%s seconds", self.session_ttl) + logger.info( + "[ENTRY] _cleanup_expired_sessions started, TTL=%s seconds", + self.session_ttl, + ) while self._running: try: @@ -700,7 +818,9 @@ async def _cleanup_expired_sessions(self) -> None: # await self.context.db.delete_platform_session(session_id) if expired_sessions: - logger.info(f"[PROCESS] Cleaned {len(expired_sessions)} expired sessions") + logger.info( + f"[PROCESS] Cleaned {len(expired_sessions)} expired sessions" + ) except Exception as e: logger.error(f"[ERROR] Session cleanup error: {e}") From a20ef8730dae621b53ceb719b0d7ebba81527305 Mon Sep 17 00:00:00 2001 From: YukiRa1n <167516635+YukiRa1n@users.noreply.github.com> Date: Sun, 1 Feb 2026 03:22:02 +0800 Subject: [PATCH 04/39] refactor(cli): fix hardcoded paths and improve code quality - Replace hardcoded paths with dynamic path resolution - Use get_astrbot_data_path() for data directory - Use get_astrbot_temp_path() for temp directory - Support ASTRBOT_ROOT environment variable - Fix asyncio deprecation warnings - Replace asyncio.get_event_loop() with get_running_loop() - Improve Python 3.10+ compatibility - Add socket file permission control - Set socket permissions to 600 (owner-only) - Add security logging - Update astrbot-cli client - Add dynamic path resolution functions - Match server-side path logic - Improve cross-environment compatibility Addresses code review feedback from PR #4787 --- astrbot-cli | 33 ++++++++++++++++--- .../core/platform/sources/cli/cli_adapter.py | 20 +++++++---- 2 files changed, 42 insertions(+), 11 deletions(-) diff --git a/astrbot-cli b/astrbot-cli index e065801d29..0c946b5e7d 100644 --- a/astrbot-cli +++ b/astrbot-cli @@ -10,18 +10,37 @@ AstrBot CLI Tool - Unix Socket客户端 import argparse import json +import os import socket import sys import uuid +def get_data_path() -> str: + """获取数据目录路径,兼容容器和非容器环境""" + # 优先使用环境变量 + if root := os.environ.get("ASTRBOT_ROOT"): + return os.path.join(root, "data") + # 默认路径 + return os.path.join(os.getcwd(), "data") + + +def get_temp_path() -> str: + """获取临时目录路径,兼容容器和非容器环境""" + # 优先使用环境变量 + if root := os.environ.get("ASTRBOT_ROOT"): + return os.path.join(root, "data", "temp") + # 默认使用系统临时目录 + return "/tmp" + + def load_auth_token() -> str: """从密钥文件加载认证token Returns: token字符串,如果文件不存在则返回空字符串 """ - token_file = "/AstrBot/data/.cli_token" + token_file = os.path.join(get_data_path(), ".cli_token") try: with open(token_file, encoding="utf-8") as f: return f.read().strip() @@ -32,18 +51,22 @@ def load_auth_token() -> str: def send_message( - message: str, socket_path: str = "/tmp/astrbot.sock", timeout: float = 30.0 + message: str, socket_path: str | None = None, timeout: float = 30.0 ) -> dict: """发送消息到AstrBot并获取响应 Args: message: 要发送的消息 - socket_path: Unix socket路径 + socket_path: Unix socket路径(默认使用临时目录下的astrbot.sock) timeout: 超时时间（秒） Returns: 响应字典 """ + # 使用默认socket路径 + if socket_path is None: + socket_path = os.path.join(get_temp_path(), "astrbot.sock") + # 加载认证token auth_token = load_auth_token() @@ -112,8 +135,8 @@ Examples: parser.add_argument( "-s", "--socket", - default="/tmp/astrbot.sock", - help="Unix socket path (default: /tmp/astrbot.sock)", + default=None, + help="Unix socket path (default: {temp_dir}/astrbot.sock)", ) parser.add_argument( diff --git a/astrbot/core/platform/sources/cli/cli_adapter.py b/astrbot/core/platform/sources/cli/cli_adapter.py index 79459a7781..f0db27124f 100644 --- a/astrbot/core/platform/sources/cli/cli_adapter.py +++ b/astrbot/core/platform/sources/cli/cli_adapter.py @@ -14,6 +14,7 @@ from astrbot import logger from astrbot.core.message.components import Plain +from astrbot.core.utils.astrbot_path import get_astrbot_data_path, get_astrbot_temp_path from astrbot.core.message.message_event_result import MessageChain from astrbot.core.platform import ( AstrBotMessage, @@ -71,7 +72,7 @@ def __init__( import os config_file = platform_config.get("config_file", "cli_config.json") - cli_config_path = f"/AstrBot/data/{config_file}" + cli_config_path = os.path.join(get_astrbot_data_path(), config_file) if os.path.exists(cli_config_path): try: with open(cli_config_path, encoding="utf-8") as f: @@ -111,7 +112,9 @@ def __init__( self.poll_interval = platform_config.get("poll_interval", 1.0) # Unix Socket配置 - self.socket_path = platform_config.get("socket_path", "/tmp/astrbot.sock") + self.socket_path = platform_config.get( + "socket_path", os.path.join(get_astrbot_temp_path(), "astrbot.sock") + ) # Token认证配置 self.auth_token = self._ensure_auth_token() @@ -157,7 +160,7 @@ def _ensure_auth_token(self) -> str | None: import os import secrets - token_file = "/AstrBot/data/.cli_token" + token_file = os.path.join(get_astrbot_data_path(), ".cli_token") logger.debug("[ENTRY] _ensure_auth_token inputs={}") @@ -355,6 +358,11 @@ async def _run_socket_mode(self) -> None: # 创建Unix socket server_socket = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM) server_socket.bind(self.socket_path) + + # 设置严格权限(仅所有者可访问) + os.chmod(self.socket_path, 0o600) + logger.info(f"[SECURITY] Socket permissions set to 600: {self.socket_path}") + server_socket.listen(5) server_socket.setblocking(False) @@ -364,7 +372,7 @@ async def _run_socket_mode(self) -> None: while self._running: try: # 接受连接（非阻塞） - loop = asyncio.get_event_loop() + loop = asyncio.get_running_loop() client_socket, _ = await loop.sock_accept(server_socket) # 处理连接（异步） @@ -395,7 +403,7 @@ async def _handle_socket_client(self, client_socket) -> None: logger.debug("[ENTRY] _handle_socket_client") try: - loop = asyncio.get_event_loop() + loop = asyncio.get_running_loop() # 接收请求数据 data = await loop.sock_recv(client_socket, 4096) @@ -563,7 +571,7 @@ async def _read_input(self) -> str: logger.debug("[ENTRY] _read_input inputs={}") # 使用asyncio在事件循环中运行阻塞的input() - loop = asyncio.get_event_loop() + loop = asyncio.get_running_loop() user_input = await loop.run_in_executor(None, input, "You: ") logger.debug("[EXIT] _read_input return={input=%s}", user_input) From ce1c26f9b800cab4d1dc7b37d033a2aa35310eb9 Mon Sep 17 00:00:00 2001 From: YukiRa1n <167516635+YukiRa1n@users.noreply.github.com> Date: Sun, 1 Feb 2026 03:57:23 +0800 Subject: [PATCH 05/39] feat(cli): support multi-round reply and large response handling - Fix client to receive large responses by using loop recv instead of single recv(4096) - Save base64 images to temp files instead of exposing in JSON response - Implement adaptive delay mechanism for multi-round reply collection: * First send: 5s delay (fast response for simple text) * Subsequent sends: 10s delay (auto-switch for tool invocation) - Support tool invocation scenarios with multiple replies (text + images) - Add detailed logging for debugging multi-round reply collection --- astrbot-cli | 19 +++++- .../core/platform/sources/cli/cli_adapter.py | 48 ++++++++++--- .../core/platform/sources/cli/cli_event.py | 68 ++++++++++++++++++- 3 files changed, 120 insertions(+), 15 deletions(-) diff --git a/astrbot-cli b/astrbot-cli index 0c946b5e7d..782714e354 100644 --- a/astrbot-cli +++ b/astrbot-cli @@ -100,10 +100,23 @@ def send_message( request_data = json.dumps(request, ensure_ascii=False).encode("utf-8") client_socket.sendall(request_data) - # 接收响应 - response_data = client_socket.recv(4096) + # 接收响应（循环接收所有数据，支持大响应如base64图片） + response_data = b"" + while True: + chunk = client_socket.recv(4096) + if not chunk: + break + response_data += chunk + # 尝试解析JSON，如果成功说明接收完整 + try: + response = json.loads(response_data.decode("utf-8")) + return response + except json.JSONDecodeError: + # JSON不完整，继续接收 + continue + + # 如果循环结束仍未成功解析，尝试最后一次 response = json.loads(response_data.decode("utf-8")) - return response except TimeoutError: diff --git a/astrbot/core/platform/sources/cli/cli_adapter.py b/astrbot/core/platform/sources/cli/cli_adapter.py index f0db27124f..9ea2a1bcd9 100644 --- a/astrbot/core/platform/sources/cli/cli_adapter.py +++ b/astrbot/core/platform/sources/cli/cli_adapter.py @@ -14,7 +14,6 @@ from astrbot import logger from astrbot.core.message.components import Plain -from astrbot.core.utils.astrbot_path import get_astrbot_data_path, get_astrbot_temp_path from astrbot.core.message.message_event_result import MessageChain from astrbot.core.platform import ( AstrBotMessage, @@ -24,6 +23,7 @@ PlatformMetadata, ) from astrbot.core.platform.astr_message_event import MessageSesion +from astrbot.core.utils.astrbot_path import get_astrbot_data_path, get_astrbot_temp_path from ...register import register_platform_adapter from .cli_event import CLIMessageEvent @@ -36,7 +36,7 @@ "type": "cli", "enable": False, # 默认关闭，开发时手动启用 "mode": "socket", # 默认使用Socket模式 - "socket_path": "/tmp/astrbot.sock", + "socket_path": None, # None表示使用动态路径(temp_dir/astrbot.sock) "whitelist": [], # 空白名单表示允许所有 "use_isolated_sessions": False, # 是否启用会话隔离（每个请求独立会话） "session_ttl": 30, # 会话过期时间（秒），仅在use_isolated_sessions=True时生效，测试用30秒，生产建议1800秒（30分钟） @@ -104,10 +104,12 @@ def __init__( # 文件I/O配置 self.input_file = platform_config.get( - "input_file", "/tmp/astrbot_cli/input.txt" + "input_file", + os.path.join(get_astrbot_temp_path(), "astrbot_cli", "input.txt"), ) self.output_file = platform_config.get( - "output_file", "/tmp/astrbot_cli/output.txt" + "output_file", + os.path.join(get_astrbot_temp_path(), "astrbot_cli", "output.txt"), ) self.poll_interval = platform_config.get("poll_interval", 1.0) @@ -519,11 +521,39 @@ async def _handle_socket_client(self, client_socket) -> None: ) image_info["error"] = str(e) elif comp.file.startswith("base64://"): - image_info["type"] = "base64" - # 返回完整的base64数据 - base64_data = comp.file[9:] - image_info["base64_data"] = base64_data - image_info["base64_length"] = len(base64_data) + # 将base64数据保存到临时文件，避免在JSON中暴露大量数据 + try: + import base64 + import os + import tempfile + + base64_data = comp.file[9:] + image_data = base64.b64decode(base64_data) + + # 生成临时文件路径 + temp_dir = get_astrbot_temp_path() + os.makedirs(temp_dir, exist_ok=True) + temp_file = tempfile.NamedTemporaryFile( + delete=False, + suffix=".png", + dir=temp_dir, + ) + temp_file.write(image_data) + temp_file.close() + + image_info["type"] = "file" + image_info["path"] = temp_file.name + image_info["size"] = len(image_data) + logger.debug( + f"[PROCESS] Saved base64 image to file: {temp_file.name}, size: {len(image_data)} bytes" + ) + except Exception as e: + logger.error( + f"[ERROR] Failed to save base64 image: {e}" + ) + image_info["type"] = "base64" + image_info["error"] = str(e) + image_info["base64_length"] = len(base64_data) images.append(image_info) # 发送成功响应 diff --git a/astrbot/core/platform/sources/cli/cli_event.py b/astrbot/core/platform/sources/cli/cli_event.py index 3bb7d28057..c6125562be 100644 --- a/astrbot/core/platform/sources/cli/cli_event.py +++ b/astrbot/core/platform/sources/cli/cli_event.py @@ -52,6 +52,11 @@ def __init__( self.output_queue = output_queue self.response_future = response_future + # 用于收集多次回复 + self.send_buffer = None + self._response_delay_task = None + self._response_delay = 3.0 # 延迟3秒收集所有回复（支持工具调用等多轮场景） + logger.debug("[EXIT] CLIMessageEvent.__init__ return=None") async def send(self, message_chain: MessageChain) -> dict[str, Any]: @@ -65,7 +70,7 @@ async def send(self, message_chain: MessageChain) -> dict[str, Any]: """ logger.debug("[ENTRY] CLIMessageEvent.send inputs={message_chain=%s}", message_chain) - # Socket模式：直接设置Future结果（返回完整MessageChain以支持图片等组件） + # Socket模式：收集多次回复 if self.response_future is not None and not self.response_future.done(): # 预处理本地文件图片：立即读取并转换为base64（避免临时文件被删除） from astrbot.core.message.components import Image @@ -86,8 +91,30 @@ async def send(self, message_chain: MessageChain) -> dict[str, Any]: except Exception as e: logger.error(f"[ERROR] Failed to read image file {file_path}: {e}") - self.response_future.set_result(message_chain) - logger.debug("[PROCESS] Set socket response future with MessageChain") + # 收集多次回复到buffer（自适应延迟机制） + if not self.send_buffer: + # 第一次send：初始化buffer，使用中等延迟（5秒） + # 5秒足够等待工具调用的第二次回复，同时不会让简单回复等太久 + self.send_buffer = message_chain + self._response_delay = 5.0 + logger.info("[PROCESS] First send: initialized buffer with 5s delay") + else: + # 后续send：追加到buffer，切换到长延迟（10秒） + # 确保能收集到所有工具调用的回复 + self.send_buffer.chain.extend(message_chain.chain) + self._response_delay = 10.0 + logger.info( + f"[PROCESS] Appended to buffer (switched to 10s delay), total: {len(self.send_buffer.chain)} components" + ) + + # 取消之前的延迟任务（如果存在） + if self._response_delay_task and not self._response_delay_task.done(): + self._response_delay_task.cancel() + logger.info("[PROCESS] Cancelled previous delay task") + + # 启动新的延迟任务（每次send都重置延迟） + self._response_delay_task = asyncio.create_task(self._delayed_response()) + logger.info(f"[PROCESS] Started new delay task ({self._response_delay}s)") else: # 其他模式：将消息放入输出队列 await self.output_queue.put(message_chain) @@ -113,3 +140,38 @@ async def reply(self, message_chain: MessageChain) -> dict[str, Any]: logger.debug("[EXIT] CLIMessageEvent.reply return=%s", result) return result + + async def _delayed_response(self) -> None: + """延迟响应：等待一段时间收集所有回复后统一返回 + + 等待 _response_delay 秒后，将累积的所有消息统一返回给客户端。 + 这样可以支持插件的多轮回复（如先发文本，再发图片）。 + """ + logger.debug( + "[ENTRY] _delayed_response inputs={delay=%s}", self._response_delay + ) + + try: + # 等待延迟时间，收集所有回复 + await asyncio.sleep(self._response_delay) + + # 检查 Future 是否还未完成 + if self.response_future and not self.response_future.done(): + # 将累积的消息设置到 Future + self.response_future.set_result(self.send_buffer) + logger.debug( + "[PROCESS] Set delayed response with %d components", + len(self.send_buffer.chain), + ) + else: + logger.warning( + "[WARN] Response future already done or None, skipping set_result" + ) + + except Exception as e: + logger.error("[ERROR] Failed to set delayed response: %s", e) + # 如果出错，尝试设置异常到 Future + if self.response_future and not self.response_future.done(): + self.response_future.set_exception(e) + + logger.debug("[EXIT] _delayed_response return=None") From c8eeb636d902ae123c2e2b41bbb1483d0545dd94 Mon Sep 17 00:00:00 2001 From: YukiRa1n <167516635+YukiRa1n@users.noreply.github.com> Date: Sun, 1 Feb 2026 04:16:01 +0800 Subject: [PATCH 06/39] fix(ci): skip release step in forked repositories - Add repository check to dashboard_ci.yml - Only create release in main repository (AstrBotDevs/AstrBot) - Prevents token error in forked repositories --- .github/workflows/dashboard_ci.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/dashboard_ci.yml b/.github/workflows/dashboard_ci.yml index 5be935ebce..97a035e7cf 100644 --- a/.github/workflows/dashboard_ci.yml +++ b/.github/workflows/dashboard_ci.yml @@ -44,7 +44,7 @@ jobs: !dist/**/*.md - name: Create GitHub Release - if: github.event_name == 'push' + if: github.event_name == 'push' && github.repository == 'AstrBotDevs/AstrBot' uses: ncipollo/release-action@v1 with: tag: release-${{ github.sha }} From ecfb62ea42a479ad21c094d1dac4f1fb990318ea Mon Sep 17 00:00:00 2001 From: YukiRa1n <167516635+YukiRa1n@users.noreply.github.com> Date: Sun, 1 Feb 2026 11:29:36 +0800 Subject: [PATCH 07/39] fix(ci): correct checkout parameter from fetch-tag to fetch-tags - Fix invalid parameter 'fetch-tag' in docker-image.yml - Should be 'fetch-tags' (plural) according to actions/checkout@v6 docs - Resolves 'Unexpected input' warning in GitHub Actions --- .github/workflows/docker-image.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.github/workflows/docker-image.yml b/.github/workflows/docker-image.yml index 18c8d49269..d5865a1ab3 100644 --- a/.github/workflows/docker-image.yml +++ b/.github/workflows/docker-image.yml @@ -23,7 +23,7 @@ jobs: uses: actions/checkout@v6 with: fetch-depth: 1 - fetch-tag: true + fetch-tags: true - name: Check for new commits today if: github.event_name == 'schedule' @@ -121,7 +121,7 @@ jobs: uses: actions/checkout@v6 with: fetch-depth: 1 - fetch-tag: true + fetch-tags: true - name: Get latest tag (only on manual trigger) id: get-latest-tag From b4b87b5cdfa33ccbd64b8800670188cb379a2e4c Mon Sep 17 00:00:00 2001 From: YukiRa1n <167516635+YukiRa1n@users.noreply.github.com> Date: Tue, 3 Feb 2026 00:43:31 +0800 Subject: [PATCH 08/39] feat(cli): add cross-platform socket support for Windows compatibility - Refactor CLI platform to support both Unix Socket and TCP Socket - Add platform detection module to auto-detect OS capabilities - Add socket factory pattern for creating appropriate socket servers - Split monolithic cli_adapter.py into modular components: * platform_detector.py: OS and socket capability detection * socket_abstract.py: Abstract base class for socket servers * socket_factory.py: Factory for creating socket servers * tcp_socket_server.py: TCP socket server implementation * unix_socket_server.py: Unix socket server implementation * connection_info_writer.py: Connection info file writer - Update astrbot-cli client to support both socket types - Fix logger imports to use AstrBot's custom logger system This enables CLI platform to work on Windows (using TCP Socket) while maintaining Unix Socket support on Linux/Mac. --- astrbot-cli | 165 +++++++++-- .../core/platform/sources/cli/cli_adapter.py | 76 +++-- .../sources/cli/connection_info_writer.py | 120 ++++++++ .../platform/sources/cli/platform_detector.py | 263 ++++++++++++++++++ .../platform/sources/cli/socket_abstract.py | 120 ++++++++ .../platform/sources/cli/socket_factory.py | 218 +++++++++++++++ .../platform/sources/cli/tcp_socket_server.py | 247 ++++++++++++++++ .../sources/cli/unix_socket_server.py | 213 ++++++++++++++ 8 files changed, 1370 insertions(+), 52 deletions(-) create mode 100644 astrbot/core/platform/sources/cli/connection_info_writer.py create mode 100644 astrbot/core/platform/sources/cli/platform_detector.py create mode 100644 astrbot/core/platform/sources/cli/socket_abstract.py create mode 100644 astrbot/core/platform/sources/cli/socket_factory.py create mode 100644 astrbot/core/platform/sources/cli/tcp_socket_server.py create mode 100644 astrbot/core/platform/sources/cli/unix_socket_server.py diff --git a/astrbot-cli b/astrbot-cli index 782714e354..5b42683580 100644 --- a/astrbot-cli +++ b/astrbot-cli @@ -1,6 +1,8 @@ #!/usr/bin/env python3 """ -AstrBot CLI Tool - Unix Socket客户端 +AstrBot CLI Tool - 跨平台Socket客户端 + +支持Unix Socket和TCP Socket连接 用法: astrbot-cli "你好" @@ -14,6 +16,7 @@ import os import socket import sys import uuid +from typing import Optional def get_data_path() -> str: @@ -50,22 +53,129 @@ def load_auth_token() -> str: return "" +def load_connection_info(data_dir: str) -> Optional[dict]: + """加载连接信息 + + 从.cli_connection文件读取Socket连接信息 + + Args: + data_dir: 数据目录路径 + + Returns: + 连接信息字典，如果文件不存在则返回None + + Example: + Unix Socket: {"type": "unix", "path": "/tmp/astrbot.sock"} + TCP Socket: {"type": "tcp", "host": "127.0.0.1", "port": 12345} + """ + connection_file = os.path.join(data_dir, ".cli_connection") + try: + with open(connection_file, encoding="utf-8") as f: + connection_info = json.load(f) + return connection_info + except FileNotFoundError: + return None + except json.JSONDecodeError as e: + print( + f"[ERROR] Invalid JSON in connection file: {connection_file}", + file=sys.stderr, + ) + print(f"[ERROR] {e}", file=sys.stderr) + return None + except Exception as e: + print( + f"[ERROR] Failed to load connection info: {e}", + file=sys.stderr, + ) + return None + + +def connect_to_server( + connection_info: dict, timeout: float = 30.0 +) -> socket.socket: + """连接到服务器 + + 根据连接信息类型选择Unix Socket或TCP Socket连接 + + Args: + connection_info: 连接信息字典 + timeout: 超时时间（秒） + + Returns: + socket连接对象 + + Raises: + ValueError: 无效的连接类型 + ConnectionError: 连接失败 + """ + socket_type = connection_info.get("type") + + if socket_type == "unix": + # Unix Socket连接 + socket_path = connection_info.get("path") + if not socket_path: + raise ValueError("Unix socket path is missing in connection info") + + try: + client_socket = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM) + client_socket.settimeout(timeout) + client_socket.connect(socket_path) + return client_socket + except FileNotFoundError: + raise ConnectionError( + f"Socket file not found: {socket_path}. Is AstrBot running?" + ) + except ConnectionRefusedError: + raise ConnectionError( + "Connection refused. Is AstrBot running in socket mode?" + ) + except Exception as e: + raise ConnectionError(f"Unix socket connection error: {e}") + + elif socket_type == "tcp": + # TCP Socket连接 + host = connection_info.get("host") + port = connection_info.get("port") + if not host or not port: + raise ValueError("TCP host or port is missing in connection info") + + try: + client_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM) + client_socket.settimeout(timeout) + client_socket.connect((host, port)) + return client_socket + except ConnectionRefusedError: + raise ConnectionError( + f"Connection refused to {host}:{port}. Is AstrBot running?" + ) + except socket.timeout: + raise ConnectionError(f"Connection timeout to {host}:{port}") + except Exception as e: + raise ConnectionError(f"TCP socket connection error: {e}") + + else: + raise ValueError( + f"Invalid socket type: {socket_type}. Expected 'unix' or 'tcp'" + ) + + def send_message( message: str, socket_path: str | None = None, timeout: float = 30.0 ) -> dict: """发送消息到AstrBot并获取响应 + 支持自动检测连接类型（Unix Socket或TCP Socket） + Args: message: 要发送的消息 - socket_path: Unix socket路径(默认使用临时目录下的astrbot.sock) + socket_path: Unix socket路径(仅用于向后兼容，优先使用.cli_connection) timeout: 超时时间（秒） Returns: 响应字典 """ - # 使用默认socket路径 - if socket_path is None: - socket_path = os.path.join(get_temp_path(), "astrbot.sock") + # [ENTRY] send_message + data_dir = get_data_path() # 加载认证token auth_token = load_auth_token() @@ -77,30 +187,33 @@ def send_message( if auth_token: request["auth_token"] = auth_token - # 连接到Unix socket + # [PROCESS] 尝试加载连接信息 + connection_info = load_connection_info(data_dir) + + # 连接到服务器 try: - client_socket = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM) - client_socket.settimeout(timeout) - client_socket.connect(socket_path) - except FileNotFoundError: - return { - "status": "error", - "error": f"Socket file not found: {socket_path}. Is AstrBot running?", - } - except ConnectionRefusedError: - return { - "status": "error", - "error": "Connection refused. Is AstrBot running in socket mode?", - } + if connection_info is not None: + # [PROCESS] 使用连接信息文件 + client_socket = connect_to_server(connection_info, timeout) + else: + # [PROCESS] 向后兼容：使用默认Unix Socket路径 + if socket_path is None: + socket_path = os.path.join(get_temp_path(), "astrbot.sock") + + fallback_info = {"type": "unix", "path": socket_path} + client_socket = connect_to_server(fallback_info, timeout) + + except (ValueError, ConnectionError) as e: + return {"status": "error", "error": str(e)} except Exception as e: return {"status": "error", "error": f"Connection error: {e}"} try: - # 发送请求 + # [PROCESS] 发送请求 request_data = json.dumps(request, ensure_ascii=False).encode("utf-8") client_socket.sendall(request_data) - # 接收响应（循环接收所有数据，支持大响应如base64图片） + # [PROCESS] 接收响应（循环接收所有数据，支持大响应如base64图片） response_data = b"" while True: chunk = client_socket.recv(4096) @@ -110,6 +223,7 @@ def send_message( # 尝试解析JSON，如果成功说明接收完整 try: response = json.loads(response_data.decode("utf-8")) + # [EXIT] send_message success return response except json.JSONDecodeError: # JSON不完整，继续接收 @@ -117,11 +231,14 @@ def send_message( # 如果循环结束仍未成功解析，尝试最后一次 response = json.loads(response_data.decode("utf-8")) + # [EXIT] send_message success return response except TimeoutError: + # [ERROR] Request timeout return {"status": "error", "error": "Request timeout"} except Exception as e: + # [ERROR] Communication error return {"status": "error", "error": f"Communication error: {e}"} finally: client_socket.close() @@ -130,7 +247,7 @@ def send_message( def main(): """主函数""" parser = argparse.ArgumentParser( - description="AstrBot CLI Tool - Send messages to AstrBot via Unix Socket", + description="AstrBot CLI Tool - Send messages to AstrBot (Unix Socket or TCP Socket)", formatter_class=argparse.RawDescriptionHelpFormatter, epilog=""" Examples: @@ -138,6 +255,10 @@ Examples: astrbot-cli "/help" astrbot-cli --socket /tmp/custom.sock "测试消息" echo "你好" | astrbot-cli + +Connection: + Automatically detects connection type from .cli_connection file. + Falls back to default Unix Socket if file not found. """, ) diff --git a/astrbot/core/platform/sources/cli/cli_adapter.py b/astrbot/core/platform/sources/cli/cli_adapter.py index 9ea2a1bcd9..077d7e893e 100644 --- a/astrbot/core/platform/sources/cli/cli_adapter.py +++ b/astrbot/core/platform/sources/cli/cli_adapter.py @@ -27,6 +27,9 @@ from ...register import register_platform_adapter from .cli_event import CLIMessageEvent +from .connection_info_writer import write_connection_info +from .platform_detector import detect_platform +from .socket_factory import create_socket_server @register_platform_adapter( @@ -36,7 +39,10 @@ "type": "cli", "enable": False, # 默认关闭，开发时手动启用 "mode": "socket", # 默认使用Socket模式 - "socket_path": None, # None表示使用动态路径(temp_dir/astrbot.sock) + "socket_type": "auto", # Socket类型: "auto"(自动检测) | "unix" | "tcp" + "socket_path": None, # Unix Socket路径，None表示使用动态路径 + "tcp_host": "127.0.0.1", # TCP Socket监听地址 + "tcp_port": 0, # TCP Socket监听端口，0表示随机端口 "whitelist": [], # 空白名单表示允许所有 "use_isolated_sessions": False, # 是否启用会话隔离（每个请求独立会话） "session_ttl": 30, # 会话过期时间（秒），仅在use_isolated_sessions=True时生效，测试用30秒，生产建议1800秒（30分钟） @@ -113,10 +119,13 @@ def __init__( ) self.poll_interval = platform_config.get("poll_interval", 1.0) - # Unix Socket配置 + # Socket配置（跨平台） + self.socket_type = platform_config.get("socket_type", "auto") self.socket_path = platform_config.get( "socket_path", os.path.join(get_astrbot_temp_path(), "astrbot.sock") ) + self.tcp_host = platform_config.get("tcp_host", "127.0.0.1") + self.tcp_port = platform_config.get("tcp_port", 0) # Token认证配置 self.auth_token = self._ensure_auth_token() @@ -342,56 +351,63 @@ async def _run_file_mode(self) -> None: logger.info("[EXIT] CLIPlatformAdapter._run_file_mode return=None") async def _run_socket_mode(self) -> None: - """Unix Socket服务器模式 + """跨平台Socket服务器模式 管道流程: - 客户端连接 → 接收JSON请求 → 解析消息 → 创建事件 → 等待响应 → 返回JSON + 平台检测 → 创建Socket服务器 → 写入连接信息 → 接受连接 → 处理请求 """ - import os - import socket + logger.info("[ENTRY] _run_socket_mode inputs={}") self._running = True - # 删除旧的socket文件 - if os.path.exists(self.socket_path): - os.remove(self.socket_path) - logger.info(f"[PROCESS] Removed old socket file: {self.socket_path}") - - # 创建Unix socket - server_socket = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM) - server_socket.bind(self.socket_path) + # 检测平台信息 + platform_info = detect_platform() + logger.info( + "[PROCESS] Platform detected: os=%s, python=%s, unix_socket=%s", + platform_info.os_type, + platform_info.python_version, + platform_info.supports_unix_socket, + ) - # 设置严格权限(仅所有者可访问) - os.chmod(self.socket_path, 0o600) - logger.info(f"[SECURITY] Socket permissions set to 600: {self.socket_path}") + # 创建Socket服务器（工厂模式） + config = { + "socket_type": self.socket_type, + "socket_path": self.socket_path, + "tcp_host": self.tcp_host, + "tcp_port": self.tcp_port, + } + server = create_socket_server(platform_info, config, self.auth_token) + logger.info("[PROCESS] Socket server created: %s", type(server).__name__) - server_socket.listen(5) - server_socket.setblocking(False) + try: + # 启动服务器 + await server.start() + logger.info("[PROCESS] Socket server started") - logger.info(f"[PROCESS] Unix Socket server started: {self.socket_path}") + # 写入连接信息供客户端读取 + connection_info = server.get_connection_info() + write_connection_info(connection_info, get_astrbot_data_path()) + logger.info("[PROCESS] Connection info written: %s", connection_info) - try: + # 接受连接循环 while self._running: try: - # 接受连接（非阻塞） - loop = asyncio.get_running_loop() - client_socket, _ = await loop.sock_accept(server_socket) + client_socket, client_addr = await server.accept_connection() + logger.debug("[PROCESS] Client connected: %s", client_addr) # 处理连接（异步） asyncio.create_task(self._handle_socket_client(client_socket)) except Exception as e: - logger.error(f"[ERROR] Socket accept error: {e}") + logger.error("[ERROR] Socket accept error: %s", e) await asyncio.sleep(0.1) except Exception as e: - logger.error(f"[ERROR] Socket mode error: {e}") + logger.error("[ERROR] Socket mode error: %s", e) finally: self._running = False - server_socket.close() - if os.path.exists(self.socket_path): - os.remove(self.socket_path) - logger.info("[EXIT] CLIPlatformAdapter._run_socket_mode return=None") + await server.stop() + logger.info("[EXIT] _run_socket_mode return=None") async def _handle_socket_client(self, client_socket) -> None: """[原子模块] SocketHandler: 处理单个socket客户端连接 diff --git a/astrbot/core/platform/sources/cli/connection_info_writer.py b/astrbot/core/platform/sources/cli/connection_info_writer.py new file mode 100644 index 0000000000..395a8281d1 --- /dev/null +++ b/astrbot/core/platform/sources/cli/connection_info_writer.py @@ -0,0 +1,120 @@ +"""ConnectionInfoWriter - 连接信息写入器 + +将Socket连接信息写入JSON文件，供客户端读取。 +遵循Unix哲学：原子化操作、显式I/O、无副作用。 +""" + +import json +import os +import tempfile +from typing import Any + +from astrbot import logger + + +def write_connection_info(connection_info: dict[str, Any], data_dir: str) -> None: + """写入连接信息到文件 + + I/O契约: + Input: + connection_info: Socket连接信息 + - type: "unix" | "tcp" + - path: str (Unix Socket) + - host: str (TCP Socket) + - port: int (TCP Socket) + data_dir: 数据目录路径 + Output: None (副作用: 写入到 {data_dir}/.cli_connection) + + Args: + connection_info: 连接信息字典 + data_dir: 数据目录路径 + + Raises: + ValueError: 连接信息格式无效 + OSError: 文件写入失败 + """ + logger.info( + "[ENTRY] write_connection_info inputs={info=%s, dir=%s}", + connection_info, + data_dir, + ) + + # 验证输入 + _validate_connection_info(connection_info) + + # 目标文件路径 + target_path = os.path.join(data_dir, ".cli_connection") + logger.debug("[PROCESS] Target file: %s", target_path) + + # 原子写入：先写临时文件，再重命名 + try: + # 创建临时文件（同目录，确保原子重命名） + fd, temp_path = tempfile.mkstemp( + dir=data_dir, prefix=".cli_connection.", suffix=".tmp" + ) + logger.debug("[PROCESS] Created temp file: %s", temp_path) + + try: + # 写入JSON数据 + with os.fdopen(fd, "w", encoding="utf-8") as f: + json.dump(connection_info, f, indent=2) + logger.debug("[PROCESS] JSON data written to temp file") + + # 尝试设置文件权限（Windows下尽力而为） + _set_file_permissions(temp_path) + + # 原子重命名 + os.replace(temp_path, target_path) + logger.info("[PROCESS] Atomic rename completed: %s", target_path) + + except Exception: + # 清理临时文件 + if os.path.exists(temp_path): + os.remove(temp_path) + logger.debug("[PROCESS] Cleaned up temp file: %s", temp_path) + raise + + except Exception as e: + logger.error("[ERROR] Failed to write connection info: %s", e) + raise + + logger.info("[EXIT] write_connection_info return=None") + + +def _validate_connection_info(connection_info: dict[str, Any]) -> None: + """验证连接信息格式 + + Args: + connection_info: 连接信息字典 + + Raises: + ValueError: 格式无效 + """ + if not isinstance(connection_info, dict): + raise ValueError("connection_info must be a dict") + + conn_type = connection_info.get("type") + if conn_type not in ("unix", "tcp"): + raise ValueError(f"Invalid type: {conn_type}, must be 'unix' or 'tcp'") + + if conn_type == "unix": + if "path" not in connection_info: + raise ValueError("Unix socket requires 'path' field") + elif conn_type == "tcp": + if "host" not in connection_info or "port" not in connection_info: + raise ValueError("TCP socket requires 'host' and 'port' fields") + + +def _set_file_permissions(file_path: str) -> None: + """设置文件权限（Windows下尽力而为） + + Args: + file_path: 文件路径 + """ + try: + # Unix/Linux: 设置600权限 + os.chmod(file_path, 0o600) + logger.debug("[SECURITY] File permissions set to 600: %s", file_path) + except (OSError, NotImplementedError) as e: + # Windows可能不支持chmod，记录警告但不失败 + logger.warning("[SECURITY] Failed to set file permissions (Windows?): %s", e) diff --git a/astrbot/core/platform/sources/cli/platform_detector.py b/astrbot/core/platform/sources/cli/platform_detector.py new file mode 100644 index 0000000000..de07dd7546 --- /dev/null +++ b/astrbot/core/platform/sources/cli/platform_detector.py @@ -0,0 +1,263 @@ +""" +Platform Detector Module + +Detects the current operating system, Python version, and Unix Socket support. +Follows Unix philosophy: single responsibility, pure function, explicit I/O. + +Architecture: + Input: None + Output: PlatformInfo(os_type, python_version, supports_unix_socket) + +Data Flow: + [Start] -> detect_platform() + -> [Detect OS] platform.system() + -> [Detect Python Version] sys.version_info + -> [Check Unix Socket Support] + -> [Return] PlatformInfo +""" + +import platform +import sys +import time +from dataclasses import dataclass +from typing import Literal + +from astrbot import logger + + +@dataclass +class PlatformInfo: + """Platform information dataclass + + Attributes: + os_type: Operating system type (windows, linux, darwin) + python_version: Python version tuple (major, minor, micro) + supports_unix_socket: Whether Unix Socket is supported + """ + + os_type: Literal["windows", "linux", "darwin"] + python_version: tuple[int, int, int] + supports_unix_socket: bool + + +def _detect_os_type() -> Literal["windows", "linux", "darwin"]: + """Detect operating system type + + Returns: + OS type string: "windows", "linux", or "darwin" + Unknown systems default to "linux" (Unix-like fallback) + """ + start_time = time.time() + logger.debug("[ENTRY] _detect_os_type inputs={}") + + system = platform.system() + logger.debug(f"[PROCESS] platform.system() returned: {system}") + + # Normalize OS type + if system == "Windows": + os_type = "windows" + elif system == "Linux": + os_type = "linux" + elif system == "Darwin": + os_type = "darwin" + else: + # Unknown OS, default to linux (Unix-like fallback) + logger.warning(f"[PROCESS] Unknown OS type: {system}, defaulting to linux") + os_type = "linux" + + duration_ms = (time.time() - start_time) * 1000 + logger.debug(f"[EXIT] _detect_os_type return={os_type} time_ms={duration_ms:.2f}") + + return os_type + + +def _detect_python_version() -> tuple[int, int, int]: + """Detect Python version + + Returns: + Python version tuple (major, minor, micro) + """ + start_time = time.time() + logger.debug("[ENTRY] _detect_python_version inputs={}") + + # Handle both sys.version_info object and tuple (for testing) + version_info = sys.version_info + if hasattr(version_info, "major"): + # Normal sys.version_info object + version = (version_info.major, version_info.minor, version_info.micro) + else: + # Tuple (used in tests with mock.patch) + version = (version_info[0], version_info[1], version_info[2]) + + duration_ms = (time.time() - start_time) * 1000 + logger.debug( + f"[EXIT] _detect_python_version return={version} time_ms={duration_ms:.2f}" + ) + + return version + + +def _check_windows_unix_socket_support(python_version: tuple[int, int, int]) -> bool: + """Check if Windows supports Unix Socket + + Requirements: + - Python 3.9+ + - Windows 10 build 17063+ + + Args: + python_version: Python version tuple + + Returns: + True if Unix Socket is supported, False otherwise + """ + start_time = time.time() + logger.debug( + f"[ENTRY] _check_windows_unix_socket_support inputs={{python_version={python_version}}}" + ) + + # Check Python version (must be 3.9+) + if python_version < (3, 9, 0): + logger.debug( + f"[PROCESS] Python version {python_version} < 3.9.0, Unix Socket not supported" + ) + duration_ms = (time.time() - start_time) * 1000 + logger.debug( + f"[EXIT] _check_windows_unix_socket_support return=False time_ms={duration_ms:.2f}" + ) + return False + + # Check Windows build version + try: + win_ver = platform.win32_ver() + logger.debug(f"[PROCESS] platform.win32_ver() returned: {win_ver}") + + # win_ver returns: (release, version, csd, ptype) + # version format: "10.0.19041" + version_str = win_ver[1] + + if not version_str: + logger.warning("[PROCESS] Unable to determine Windows build version") + duration_ms = (time.time() - start_time) * 1000 + logger.debug( + f"[EXIT] _check_windows_unix_socket_support return=False time_ms={duration_ms:.2f}" + ) + return False + + # Parse build number from version string + # Format: "major.minor.build" + parts = version_str.split(".") + if len(parts) >= 3: + build = int(parts[2]) + logger.debug(f"[PROCESS] Windows build number: {build}") + + # Unix Socket support requires build 17063+ + if build >= 17063: + logger.debug(f"[PROCESS] Build {build} >= 17063, Unix Socket supported") + supports = True + else: + logger.debug( + f"[PROCESS] Build {build} < 17063, Unix Socket not supported" + ) + supports = False + else: + logger.warning( + f"[PROCESS] Unable to parse build number from version: {version_str}" + ) + supports = False + + except Exception as e: + logger.error(f"[ERROR] Failed to check Windows version: {e}", exc_info=True) + supports = False + + duration_ms = (time.time() - start_time) * 1000 + logger.debug( + f"[EXIT] _check_windows_unix_socket_support return={supports} time_ms={duration_ms:.2f}" + ) + + return supports + + +def _check_unix_socket_support( + os_type: Literal["windows", "linux", "darwin"], python_version: tuple[int, int, int] +) -> bool: + """Check if Unix Socket is supported on current platform + + Logic: + - Linux/Darwin: Always supported + - Windows: Requires Python 3.9+ and Windows 10 build 17063+ + + Args: + os_type: Operating system type + python_version: Python version tuple + + Returns: + True if Unix Socket is supported, False otherwise + """ + start_time = time.time() + logger.debug( + f"[ENTRY] _check_unix_socket_support inputs={{os_type={os_type}, python_version={python_version}}}" + ) + + if os_type in ("linux", "darwin"): + logger.debug(f"[PROCESS] OS type {os_type} always supports Unix Socket") + supports = True + elif os_type == "windows": + logger.debug("[PROCESS] Checking Windows Unix Socket support") + supports = _check_windows_unix_socket_support(python_version) + else: + # Unknown OS, assume Unix Socket support (Unix-like fallback) + logger.warning( + f"[PROCESS] Unknown OS type {os_type}, assuming Unix Socket support" + ) + supports = True + + duration_ms = (time.time() - start_time) * 1000 + logger.debug( + f"[EXIT] _check_unix_socket_support return={supports} time_ms={duration_ms:.2f}" + ) + + return supports + + +def detect_platform() -> PlatformInfo: + """Detect platform information + + Pure function with no side effects (except logging). + Detects OS type, Python version, and Unix Socket support. + + Returns: + PlatformInfo: Platform information dataclass + + Example: + >>> info = detect_platform() + >>> print(f"OS: {info.os_type}, Python: {info.python_version}") + OS: windows, Python: (3, 10, 0) + """ + start_time = time.time() + logger.info("[ENTRY] detect_platform inputs={}") + + # Step 1: Detect OS type + os_type = _detect_os_type() + logger.info(f"[PROCESS] Detected OS type: {os_type}") + + # Step 2: Detect Python version + python_version = _detect_python_version() + logger.info(f"[PROCESS] Detected Python version: {python_version}") + + # Step 3: Check Unix Socket support + supports_unix_socket = _check_unix_socket_support(os_type, python_version) + logger.info(f"[PROCESS] Unix Socket support: {supports_unix_socket}") + + # Step 4: Create PlatformInfo + platform_info = PlatformInfo( + os_type=os_type, + python_version=python_version, + supports_unix_socket=supports_unix_socket, + ) + + duration_ms = (time.time() - start_time) * 1000 + logger.info( + f"[EXIT] detect_platform return={platform_info} time_ms={duration_ms:.2f}" + ) + + return platform_info diff --git a/astrbot/core/platform/sources/cli/socket_abstract.py b/astrbot/core/platform/sources/cli/socket_abstract.py new file mode 100644 index 0000000000..2ec28f20aa --- /dev/null +++ b/astrbot/core/platform/sources/cli/socket_abstract.py @@ -0,0 +1,120 @@ +""" +Abstract Socket Server Interface + +This module defines the abstract base class for socket server implementations. +It provides a unified interface for both Unix Socket and TCP Socket servers, +enabling platform-independent socket communication. + +Design Pattern: Abstract Factory Pattern +I/O Contract: Defines abstract methods that must be implemented by concrete classes +""" + +from abc import ABC, abstractmethod +from typing import Any + + +class AbstractSocketServer(ABC): + """Socket服务器抽象基类 + + 定义统一的Socket服务器接口，供UnixSocketServer和TCPSocketServer实现。 + 所有子类必须实现全部抽象方法。 + + Design Principles: + - Single Responsibility: 仅定义接口契约 + - Open/Closed: 对扩展开放，对修改封闭 + - Liskov Substitution: 子类可替换父类 + + Usage: + class MySocketServer(AbstractSocketServer): + async def start(self) -> None: + # Implementation + pass + + async def stop(self) -> None: + # Implementation + pass + + async def accept_connection(self) -> tuple[Any, Any]: + # Implementation + return (client_socket, client_address) + + def get_connection_info(self) -> dict: + # Implementation + return {"type": "unix", "path": "/tmp/socket"} + """ + + @abstractmethod + async def start(self) -> None: + """启动服务器 + + 启动Socket服务器并开始监听连接。此方法应该是非阻塞的， + 使用asyncio事件循环处理连接。 + + Input: None + Output: None (副作用：启动服务器，开始监听) + + Raises: + OSError: 如果端口已被占用或权限不足 + RuntimeError: 如果服务器已经在运行 + + Example: + server = MySocketServer() + await server.start() + """ + pass + + @abstractmethod + async def stop(self) -> None: + """停止服务器 + + 停止Socket服务器并清理所有资源（关闭socket、删除文件等）。 + 此方法应该优雅地关闭所有活动连接。 + + Input: None + Output: None (副作用：停止服务器，清理资源) + + Example: + await server.stop() + """ + pass + + @abstractmethod + async def accept_connection(self) -> tuple[Any, Any]: + """接受客户端连接 + + 等待并接受一个客户端连接。此方法应该是非阻塞的， + 使用asyncio事件循环等待连接。 + + Input: None + Output: (client_socket, client_address) + - client_socket: 客户端socket对象 + - client_address: 客户端地址（Unix Socket为空字符串，TCP为(host, port)） + + Raises: + OSError: 如果socket已关闭或发生网络错误 + + Example: + client, addr = await server.accept_connection() + """ + pass + + @abstractmethod + def get_connection_info(self) -> dict: + """获取连接信息 + + 返回客户端连接到此服务器所需的信息。 + 不同类型的socket返回不同的字段。 + + Input: None + Output: dict - 连接信息字典 + Unix Socket: {"type": "unix", "path": "/path/to/socket"} + TCP Socket: {"type": "tcp", "host": "127.0.0.1", "port": 12345} + + Example: + info = server.get_connection_info() + if info["type"] == "unix": + print(f"Connect to: {info['path']}") + elif info["type"] == "tcp": + print(f"Connect to: {info['host']}:{info['port']}") + """ + pass diff --git a/astrbot/core/platform/sources/cli/socket_factory.py b/astrbot/core/platform/sources/cli/socket_factory.py new file mode 100644 index 0000000000..810ff12622 --- /dev/null +++ b/astrbot/core/platform/sources/cli/socket_factory.py @@ -0,0 +1,218 @@ +""" +Socket Factory Module + +Creates appropriate socket server instances based on platform information +and configuration. Follows the Factory Pattern to encapsulate creation logic. + +Architecture: + Input: PlatformInfo + config dict + auth_token + Output: AbstractSocketServer instance (UnixSocketServer or TCPSocketServer) + +Data Flow: + [Platform Info] + [Config] + [Auth Token] + | + v + [Decision Logic] + | + +----+----+ + | | + v v + Unix TCP + Socket Socket + Server Server +""" + +import os +import time +from typing import Literal + +from astrbot import logger +from astrbot.core.utils.astrbot_path import get_astrbot_temp_path + +from .platform_detector import PlatformInfo +from .socket_abstract import AbstractSocketServer +from .tcp_socket_server import TCPSocketServer +from .unix_socket_server import UnixSocketServer + + +def _determine_socket_type( + platform_info: PlatformInfo, config: dict +) -> Literal["unix", "tcp"]: + """Determine which socket type to use + + Decision Logic: + 1. Check explicit user specification + 2. Auto-detect based on platform + 3. Fallback to auto-detection for invalid values + + Args: + platform_info: Platform detection result + config: Configuration dictionary + + Returns: + Socket type: "unix" or "tcp" + """ + start_time = time.time() + logger.debug( + f"[ENTRY] _determine_socket_type inputs={{platform_info={platform_info}, config={config}}}" + ) + + socket_type_config = config.get("socket_type", "auto") + logger.debug(f"[PROCESS] socket_type from config: {socket_type_config}") + + # Step 1: Handle explicit specification + if socket_type_config == "tcp": + logger.info("[PROCESS] Explicitly specified socket_type=tcp") + result = "tcp" + elif socket_type_config == "unix": + logger.info("[PROCESS] Explicitly specified socket_type=unix") + result = "unix" + elif socket_type_config == "auto": + # Step 2: Auto-detection + logger.debug("[PROCESS] Auto-detection mode") + if ( + platform_info.os_type == "windows" + and not platform_info.supports_unix_socket + ): + logger.info( + "[PROCESS] Auto-detected: Windows without Unix Socket support, using TCP" + ) + result = "tcp" + else: + logger.info( + f"[PROCESS] Auto-detected: {platform_info.os_type} with Unix Socket support, using Unix" + ) + result = "unix" + else: + # Step 3: Invalid value, fallback to auto-detection + logger.warning( + f"[PROCESS] Invalid socket_type '{socket_type_config}', falling back to auto-detection" + ) + if ( + platform_info.os_type == "windows" + and not platform_info.supports_unix_socket + ): + result = "tcp" + else: + result = "unix" + + duration_ms = (time.time() - start_time) * 1000 + logger.debug( + f"[EXIT] _determine_socket_type return={result} time_ms={duration_ms:.2f}" + ) + + return result + + +def _create_unix_socket_server( + config: dict, auth_token: str | None +) -> AbstractSocketServer: + """Create Unix Socket server instance + + Args: + config: Configuration dictionary + auth_token: Authentication token + + Returns: + UnixSocketServer instance + """ + start_time = time.time() + logger.debug( + f"[ENTRY] _create_unix_socket_server inputs={{config={config}, auth_token={'***' if auth_token else None}}}" + ) + + # Get socket path from config or use default (handle None values) + socket_path = config.get("socket_path") or os.path.join( + get_astrbot_temp_path(), "astrbot.sock" + ) + logger.debug(f"[PROCESS] Using Unix Socket path: {socket_path}") + + # Create Unix Socket server + server = UnixSocketServer(socket_path=socket_path, auth_token=auth_token) + + duration_ms = (time.time() - start_time) * 1000 + logger.debug( + f"[EXIT] _create_unix_socket_server return=UnixSocketServer time_ms={duration_ms:.2f}" + ) + + return server + + +def _create_tcp_socket_server( + config: dict, auth_token: str | None +) -> AbstractSocketServer: + """Create TCP Socket server instance + + Args: + config: Configuration dictionary + auth_token: Authentication token + + Returns: + TCPSocketServer instance + """ + start_time = time.time() + logger.debug( + f"[ENTRY] _create_tcp_socket_server inputs={{config={config}, auth_token={'***' if auth_token else None}}}" + ) + + # Get TCP configuration from config or use defaults + tcp_host = config.get("tcp_host", "127.0.0.1") + tcp_port = config.get("tcp_port", 0) + logger.debug(f"[PROCESS] Using TCP host: {tcp_host}, port: {tcp_port}") + + # Create TCP Socket server + server = TCPSocketServer(host=tcp_host, port=tcp_port, auth_token=auth_token) + + duration_ms = (time.time() - start_time) * 1000 + logger.debug( + f"[EXIT] _create_tcp_socket_server return=TCPSocketServer time_ms={duration_ms:.2f}" + ) + + return server + + +def create_socket_server( + platform_info: PlatformInfo, config: dict, auth_token: str | None +) -> AbstractSocketServer: + """Create socket server based on platform and configuration + + Decision Logic: + 1. User explicitly specifies socket_type ("unix" or "tcp") + 2. Auto-detection mode: Windows without Unix Socket support uses TCP + 3. Fallback strategy: Invalid config falls back to auto-detection + + Args: + platform_info: Platform detection result + config: Configuration dictionary containing socket_type, paths, etc. + auth_token: Authentication token (optional) + + Returns: + AbstractSocketServer instance (UnixSocketServer or TCPSocketServer) + + Example: + >>> platform_info = detect_platform() + >>> config = {"socket_type": "auto"} + >>> server = create_socket_server(platform_info, config, "token123") + """ + start_time = time.time() + logger.info( + f"[ENTRY] create_socket_server inputs={{platform_info={platform_info}, " + f"socket_type={config.get('socket_type', 'auto')}, auth_token={'***' if auth_token else None}}}" + ) + + # Step 1: Determine socket type + socket_type = _determine_socket_type(platform_info, config) + logger.info(f"[PROCESS] Selected socket type: {socket_type}") + + # Step 2: Create appropriate server + if socket_type == "tcp": + server = _create_tcp_socket_server(config, auth_token) + else: # socket_type == "unix" + server = _create_unix_socket_server(config, auth_token) + + duration_ms = (time.time() - start_time) * 1000 + logger.info( + f"[EXIT] create_socket_server return={server.__class__.__name__} time_ms={duration_ms:.2f}" + ) + + return server diff --git a/astrbot/core/platform/sources/cli/tcp_socket_server.py b/astrbot/core/platform/sources/cli/tcp_socket_server.py new file mode 100644 index 0000000000..0016d15ed8 --- /dev/null +++ b/astrbot/core/platform/sources/cli/tcp_socket_server.py @@ -0,0 +1,247 @@ +""" +TCP Socket Server Implementation + +This module provides a TCP Socket server implementation for Windows compatibility. +It implements the AbstractSocketServer interface using TCP sockets (AF_INET). + +Design Pattern: Strategy Pattern (implements AbstractSocketServer) +Security: Localhost-only binding + Token authentication + +I/O Contract: + Input: host (str), port (int), auth_token (str | None) + Output: AbstractSocketServer instance with TCP socket functionality +""" + +import asyncio +import socket +import time +from typing import Any + +from astrbot import logger + +from .socket_abstract import AbstractSocketServer + + +class TCPSocketServer(AbstractSocketServer): + """TCP Socket服务器实现 + + 用于Windows环境的Socket服务器，使用TCP协议（AF_INET）。 + 仅监听localhost（127.0.0.1），通过Token认证保证安全性。 + + Attributes: + host: 监听地址（默认127.0.0.1） + port: 监听端口（0表示随机端口） + auth_token: 认证Token（可选但强烈推荐） + server_socket: TCP socket对象 + actual_port: 实际绑定的端口号 + + Security: + - 仅监听localhost，不暴露到网络 + - 支持Token认证（应用层安全） + - 记录所有连接尝试 + + Example: + server = TCPSocketServer(port=0, auth_token="secret") + await server.start() + client, addr = await server.accept_connection() + await server.stop() + """ + + def __init__( + self, host: str = "127.0.0.1", port: int = 0, auth_token: str | None = None + ): + """初始化TCP Socket服务器 + + Args: + host: 监听地址，默认127.0.0.1（仅本地访问） + port: 监听端口，0表示随机端口 + auth_token: 认证Token，用于验证客户端身份 + + Note: + 强烈建议设置auth_token，因为TCP Socket无文件权限保护 + """ + self.host = host + self.port = port + self.auth_token = auth_token + self.server_socket: socket.socket | None = None + self.actual_port: int = port + self._is_running = False + + async def start(self) -> None: + """启动TCP Socket服务器 + + 创建TCP socket，绑定到指定地址和端口，开始监听连接。 + 使用非阻塞模式，与asyncio事件循环集成。 + + Input: None + Output: None (副作用：启动服务器，开始监听) + + Raises: + RuntimeError: 如果服务器已经在运行 + OSError: 如果端口已被占用或权限不足 + + Logging: + [ENTRY] start inputs={host, port} + [PROCESS] Socket created and bound + [EXIT] start return=None time_ms={duration} + """ + start_time = time.time() + logger.debug( + f"[ENTRY] TCPSocketServer.start inputs={{host={self.host}, port={self.port}}}" + ) + + if self._is_running: + logger.error("[ERROR] TCPSocketServer.start: Server already running") + raise RuntimeError("Server is already running") + + try: + # Create TCP socket + self.server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM) + self.server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) + logger.debug("[PROCESS] TCP socket created") + + # Bind to localhost only (security) + self.server_socket.bind((self.host, self.port)) + self.actual_port = self.server_socket.getsockname()[1] + logger.debug(f"[PROCESS] Socket bound to {self.host}:{self.actual_port}") + + # Start listening + self.server_socket.listen(5) + self.server_socket.setblocking(False) + logger.debug("[PROCESS] Socket listening (non-blocking mode)") + + self._is_running = True + + duration_ms = (time.time() - start_time) * 1000 + logger.info( + f"[EXIT] TCPSocketServer.start return=None time_ms={duration_ms:.2f} " + f"actual_port={self.actual_port}" + ) + + except Exception as e: + logger.error( + f"[ERROR] TCPSocketServer.start failed: {type(e).__name__}: {e}", + exc_info=True, + ) + # Cleanup on failure + if self.server_socket: + self.server_socket.close() + self.server_socket = None + raise + + async def stop(self) -> None: + """停止TCP Socket服务器 + + 关闭socket连接并清理所有资源。 + 此方法是幂等的，可以安全地多次调用。 + + Input: None + Output: None (副作用：停止服务器，清理资源) + + Logging: + [ENTRY] stop inputs={} + [PROCESS] Closing socket + [EXIT] stop return=None time_ms={duration} + """ + start_time = time.time() + logger.debug("[ENTRY] TCPSocketServer.stop inputs={}") + + if not self._is_running and self.server_socket is None: + logger.debug("[PROCESS] Server not running, nothing to stop") + return + + try: + if self.server_socket: + logger.debug("[PROCESS] Closing TCP socket") + self.server_socket.close() + self.server_socket = None + + self._is_running = False + + duration_ms = (time.time() - start_time) * 1000 + logger.info( + f"[EXIT] TCPSocketServer.stop return=None time_ms={duration_ms:.2f}" + ) + + except Exception as e: + logger.error( + f"[ERROR] TCPSocketServer.stop failed: {type(e).__name__}: {e}", + exc_info=True, + ) + # Ensure cleanup even on error + self.server_socket = None + self._is_running = False + raise + + async def accept_connection(self) -> tuple[Any, Any]: + """接受客户端连接 + + 等待并接受一个客户端连接。使用asyncio事件循环实现非阻塞等待。 + + Input: None + Output: (client_socket, client_address) + - client_socket: 客户端socket对象 + - client_address: 客户端地址元组 (host, port) + + Raises: + OSError: 如果socket已关闭或发生网络错误 + RuntimeError: 如果服务器未启动 + + Logging: + [ENTRY] accept_connection inputs={} + [PROCESS] Waiting for connection + [PROCESS] Connection accepted from {address} + [EXIT] accept_connection return=(socket, address) time_ms={duration} + """ + start_time = time.time() + logger.debug("[ENTRY] TCPSocketServer.accept_connection inputs={}") + + if not self._is_running or self.server_socket is None: + logger.error( + "[ERROR] TCPSocketServer.accept_connection: Server not started" + ) + raise RuntimeError("Server is not running") + + try: + logger.debug("[PROCESS] Waiting for client connection") + + # Use asyncio event loop for non-blocking accept + loop = asyncio.get_event_loop() + client_socket, client_address = await loop.sock_accept(self.server_socket) + + logger.debug(f"[PROCESS] Connection accepted from {client_address}") + + duration_ms = (time.time() - start_time) * 1000 + logger.info( + f"[EXIT] TCPSocketServer.accept_connection " + f"return=(socket, {client_address}) time_ms={duration_ms:.2f}" + ) + + return client_socket, client_address + + except Exception as e: + logger.error( + f"[ERROR] TCPSocketServer.accept_connection failed: {type(e).__name__}: {e}", + exc_info=True, + ) + raise + + def get_connection_info(self) -> dict: + """获取连接信息 + + 返回客户端连接到此服务器所需的信息。 + 包含socket类型、主机地址和端口号。 + + Input: None + Output: dict - 连接信息字典 + { + "type": "tcp", + "host": "127.0.0.1", + "port": 12345 + } + + Example: + info = server.get_connection_info() + print(f"Connect to: {info['host']}:{info['port']}") + """ + return {"type": "tcp", "host": self.host, "port": self.actual_port} diff --git a/astrbot/core/platform/sources/cli/unix_socket_server.py b/astrbot/core/platform/sources/cli/unix_socket_server.py new file mode 100644 index 0000000000..6d8641d838 --- /dev/null +++ b/astrbot/core/platform/sources/cli/unix_socket_server.py @@ -0,0 +1,213 @@ +""" +Unix Socket Server Implementation + +This module provides Unix Socket server implementation for Linux/Unix environments. +It handles socket creation, permission management, and connection acceptance. + +Design Pattern: Concrete implementation of AbstractSocketServer +I/O Contract: Implements all abstract methods defined in AbstractSocketServer +""" + +import asyncio +import os +import socket +from typing import Any + +from astrbot import logger + +from .socket_abstract import AbstractSocketServer + + +class UnixSocketServer(AbstractSocketServer): + """Unix Socket服务器实现 + + 职责： + - 创建和管理Unix Domain Socket + - 设置严格的文件权限(0o600) + - 接受客户端连接 + - 清理资源 + + I/O契约： + Input: socket_path (str), auth_token (str | None) + Output: AbstractSocketServer实例 + + 设计原则： + - Single Responsibility: 仅处理Unix Socket相关逻辑 + - Explicit I/O: 所有输入通过构造函数，输出通过方法返回 + - Stateless where possible: 最小化内部状态 + + Usage: + server = UnixSocketServer(socket_path="/tmp/app.sock") + await server.start() + client, addr = await server.accept_connection() + await server.stop() + """ + + def __init__(self, socket_path: str, auth_token: str | None = None) -> None: + """初始化Unix Socket服务器 + + Args: + socket_path: Socket文件路径 + auth_token: 认证Token（可选，用于上层验证） + + Raises: + ValueError: 如果socket_path为空 + """ + logger.info( + "[ENTRY] UnixSocketServer.__init__ inputs={socket_path=%s, has_token=%s}", + socket_path, + auth_token is not None, + ) + + if not socket_path: + raise ValueError("socket_path cannot be empty") + + self.socket_path = socket_path + self.auth_token = auth_token + self._server_socket: socket.socket | None = None + self._running = False + + logger.info("[EXIT] UnixSocketServer.__init__ return=None") + + async def start(self) -> None: + """启动Unix Socket服务器 + + 创建socket文件，设置权限，开始监听连接。 + + I/O契约： + Input: None + Output: None (副作用：创建socket文件，开始监听) + + Raises: + RuntimeError: 如果服务器已经在运行 + OSError: 如果无法创建socket或设置权限 + + Implementation: + 1. 检查是否已启动 + 2. 删除旧的socket文件（如果存在） + 3. 创建AF_UNIX socket + 4. 绑定到socket_path + 5. 设置0o600权限 + 6. 开始监听（backlog=5） + 7. 设置非阻塞模式 + """ + logger.info("[ENTRY] UnixSocketServer.start inputs=None") + + if self._running: + raise RuntimeError("Server is already running") + + # 删除旧的socket文件 + if os.path.exists(self.socket_path): + os.remove(self.socket_path) + logger.info("[PROCESS] Removed old socket file: %s", self.socket_path) + + # 创建Unix socket + self._server_socket = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM) + self._server_socket.bind(self.socket_path) + logger.info("[PROCESS] Socket bound to: %s", self.socket_path) + + # 设置严格权限(仅所有者可访问) + os.chmod(self.socket_path, 0o600) + logger.info("[SECURITY] Socket permissions set to 600: %s", self.socket_path) + + # 开始监听 + self._server_socket.listen(5) + self._server_socket.setblocking(False) + self._running = True + + logger.info("[EXIT] UnixSocketServer.start return=None") + + async def stop(self) -> None: + """停止Unix Socket服务器 + + 关闭socket连接，删除socket文件，清理资源。 + + I/O契约： + Input: None + Output: None (副作用：关闭socket，删除文件) + + Implementation: + 1. 标记为非运行状态 + 2. 关闭server socket + 3. 删除socket文件 + 4. 清理内部状态 + """ + logger.info("[ENTRY] UnixSocketServer.stop inputs=None") + + self._running = False + + # 关闭socket + if self._server_socket is not None: + try: + self._server_socket.close() + logger.info("[PROCESS] Server socket closed") + except Exception as e: + logger.error("[ERROR] Failed to close socket: %s", e) + + # 删除socket文件 + if os.path.exists(self.socket_path): + try: + os.remove(self.socket_path) + logger.info("[PROCESS] Socket file removed: %s", self.socket_path) + except Exception as e: + logger.error("[ERROR] Failed to remove socket file: %s", e) + + self._server_socket = None + logger.info("[EXIT] UnixSocketServer.stop return=None") + + async def accept_connection(self) -> tuple[Any, Any]: + """接受客户端连接 + + 等待并接受一个客户端连接。使用asyncio事件循环实现非阻塞等待。 + + I/O契约： + Input: None + Output: (client_socket, client_address) + - client_socket: 客户端socket对象 + - client_address: 客户端地址（Unix Socket为空字符串） + + Raises: + RuntimeError: 如果服务器未启动 + OSError: 如果socket已关闭或发生网络错误 + + Implementation: + 1. 检查服务器是否已启动 + 2. 使用asyncio.loop.sock_accept()非阻塞等待连接 + 3. 返回客户端socket和地址 + """ + logger.debug("[ENTRY] UnixSocketServer.accept_connection inputs=None") + + if not self._running or self._server_socket is None: + raise RuntimeError("Server is not started") + + # 使用asyncio事件循环接受连接（非阻塞） + loop = asyncio.get_running_loop() + client_socket, client_addr = await loop.sock_accept(self._server_socket) + + logger.debug( + "[EXIT] UnixSocketServer.accept_connection return=(socket, %s)", client_addr + ) + return client_socket, client_addr + + def get_connection_info(self) -> dict: + """获取连接信息 + + 返回客户端连接到此服务器所需的信息。 + + I/O契约： + Input: None + Output: dict - 连接信息字典 + { + "type": "unix", + "path": "/path/to/socket" + } + + Implementation: + 返回包含socket类型和路径的字典 + """ + logger.debug("[ENTRY] UnixSocketServer.get_connection_info inputs=None") + + info = {"type": "unix", "path": self.socket_path} + + logger.debug("[EXIT] UnixSocketServer.get_connection_info return=%s", info) + return info From 1ef67c0de1d78b5f51fc9de558fd526b846141fc Mon Sep 17 00:00:00 2001 From: YukiRa1n <167516635+YukiRa1n@users.noreply.github.com> Date: Thu, 5 Feb 2026 18:07:05 +0800 Subject: [PATCH 09/39] =?UTF-8?q?refactor(cli):=20=E9=87=8D=E6=9E=84CLI?= =?UTF-8?q?=E9=80=82=E9=85=8D=E5=99=A8=E4=B8=BA=E6=A8=A1=E5=9D=97=E5=8C=96?= =?UTF-8?q?=E6=9E=B6=E6=9E=84?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - cli_adapter.py: 897行 → 204行 (77%精简) - cli_event.py: 194行 → 116行 - 新增76个单元测试，全部通过 - config/: ConfigLoader, TokenManager - handlers/: SocketHandler, TTYHandler, FileHandler - message/: MessageConverter, ImageProcessor, ResponseBuilder - session/: SessionManager - utils/: AOP装饰器集合 (异常处理/重试/超时/日志/权限) - 单一职责: 每个模块职责单一 - 依赖倒置: IHandler/IMessageConverter等接口 - AOP: 横切关注点从业务代码抽离 - 组合优于继承: 通过组合构建复杂功能 - Windows UTF-8输出乱码问题 --- astrbot-cli | 11 +- .../core/platform/sources/cli/cli_adapter.py | 918 +++--------------- .../core/platform/sources/cli/cli_event.py | 147 +-- .../platform/sources/cli/config/__init__.py | 6 + .../sources/cli/config/config_loader.py | 224 +++++ .../sources/cli/config/token_manager.py | 99 ++ .../platform/sources/cli/handlers/__init__.py | 7 + .../sources/cli/handlers/file_handler.py | 159 +++ .../sources/cli/handlers/socket_handler.py | 238 +++++ .../sources/cli/handlers/tty_handler.py | 125 +++ .../core/platform/sources/cli/interfaces.py | 91 ++ .../platform/sources/cli/message/__init__.py | 14 + .../platform/sources/cli/message/converter.py | 74 ++ .../sources/cli/message/image_processor.py | 247 +++++ .../sources/cli/message/response_builder.py | 84 ++ .../sources/cli/message/response_collector.py | 104 ++ .../platform/sources/cli/platform_detector.py | 70 +- .../platform/sources/cli/session/__init__.py | 5 + .../sources/cli/session/session_manager.py | 123 +++ .../platform/sources/cli/utils/__init__.py | 56 ++ .../platform/sources/cli/utils/decorators.py | 496 ++++++++++ tests/test_cli/__init__.py | 1 + tests/test_cli/conftest.py | 37 + tests/test_cli/test_decorators.py | 408 ++++++++ tests/test_cli/test_e2e.py | 288 ++++++ tests/test_cli/test_image_processor.py | 241 +++++ tests/test_cli/test_message_converter.py | 91 ++ tests/test_cli/test_response_builder.py | 115 +++ tests/test_cli/test_token_manager.py | 114 +++ 29 files changed, 3644 insertions(+), 949 deletions(-) create mode 100644 astrbot/core/platform/sources/cli/config/__init__.py create mode 100644 astrbot/core/platform/sources/cli/config/config_loader.py create mode 100644 astrbot/core/platform/sources/cli/config/token_manager.py create mode 100644 astrbot/core/platform/sources/cli/handlers/__init__.py create mode 100644 astrbot/core/platform/sources/cli/handlers/file_handler.py create mode 100644 astrbot/core/platform/sources/cli/handlers/socket_handler.py create mode 100644 astrbot/core/platform/sources/cli/handlers/tty_handler.py create mode 100644 astrbot/core/platform/sources/cli/interfaces.py create mode 100644 astrbot/core/platform/sources/cli/message/__init__.py create mode 100644 astrbot/core/platform/sources/cli/message/converter.py create mode 100644 astrbot/core/platform/sources/cli/message/image_processor.py create mode 100644 astrbot/core/platform/sources/cli/message/response_builder.py create mode 100644 astrbot/core/platform/sources/cli/message/response_collector.py create mode 100644 astrbot/core/platform/sources/cli/session/__init__.py create mode 100644 astrbot/core/platform/sources/cli/session/session_manager.py create mode 100644 astrbot/core/platform/sources/cli/utils/__init__.py create mode 100644 astrbot/core/platform/sources/cli/utils/decorators.py create mode 100644 tests/test_cli/__init__.py create mode 100644 tests/test_cli/conftest.py create mode 100644 tests/test_cli/test_decorators.py create mode 100644 tests/test_cli/test_e2e.py create mode 100644 tests/test_cli/test_image_processor.py create mode 100644 tests/test_cli/test_message_converter.py create mode 100644 tests/test_cli/test_response_builder.py create mode 100644 tests/test_cli/test_token_manager.py diff --git a/astrbot-cli b/astrbot-cli index 5b42683580..c3e6741c1e 100644 --- a/astrbot-cli +++ b/astrbot-cli @@ -11,6 +11,7 @@ AstrBot CLI Tool - 跨平台Socket客户端 """ import argparse +import io import json import os import socket @@ -18,6 +19,12 @@ import sys import uuid from typing import Optional +# Windows UTF-8 输出支持 +if sys.platform == "win32": + # 设置stdout/stderr为UTF-8编码 + sys.stdout = io.TextIOWrapper(sys.stdout.buffer, encoding="utf-8", errors="replace") + sys.stderr = io.TextIOWrapper(sys.stderr.buffer, encoding="utf-8", errors="replace") + def get_data_path() -> str: """获取数据目录路径,兼容容器和非容器环境""" @@ -90,9 +97,7 @@ def load_connection_info(data_dir: str) -> Optional[dict]: return None -def connect_to_server( - connection_info: dict, timeout: float = 30.0 -) -> socket.socket: +def connect_to_server(connection_info: dict, timeout: float = 30.0) -> socket.socket: """连接到服务器 根据连接信息类型选择Unix Socket或TCP Socket连接 diff --git a/astrbot/core/platform/sources/cli/cli_adapter.py b/astrbot/core/platform/sources/cli/cli_adapter.py index 077d7e893e..0c2550dc3a 100644 --- a/astrbot/core/platform/sources/cli/cli_adapter.py +++ b/astrbot/core/platform/sources/cli/cli_adapter.py @@ -1,34 +1,38 @@ """ -CLI Tester - CLI测试器 +CLI Platform Adapter - CLI平台适配器 -用于快速测试和调试AstrBot插件，无需连接真实的IM平台。 -构建快速反馈循环，支持Vibe Coding开发模式。 +编排层：组合各模块实现CLI测试功能。 遵循Unix哲学：原子化模块、显式I/O、管道编排。 + +重构后架构: + cli_adapter.py (编排层 <200行) + ├── ConfigLoader 加载配置 + ├── TokenManager 管理认证 + ├── SessionManager 管理会话 + ├── MessageConverter 转换消息 + └── Handler (Socket/TTY/File) """ import asyncio -import sys -import uuid from collections.abc import Awaitable from typing import Any from astrbot import logger -from astrbot.core.message.components import Plain from astrbot.core.message.message_event_result import MessageChain -from astrbot.core.platform import ( - AstrBotMessage, - MessageMember, - MessageType, - Platform, - PlatformMetadata, -) +from astrbot.core.platform import Platform, PlatformMetadata from astrbot.core.platform.astr_message_event import MessageSesion -from astrbot.core.utils.astrbot_path import get_astrbot_data_path, get_astrbot_temp_path +from astrbot.core.utils.astrbot_path import get_astrbot_data_path from ...register import register_platform_adapter -from .cli_event import CLIMessageEvent +from .config.config_loader import ConfigLoader +from .config.token_manager import TokenManager from .connection_info_writer import write_connection_info +from .handlers.file_handler import FileHandler +from .handlers.socket_handler import SocketClientHandler, SocketModeHandler +from .handlers.tty_handler import TTYHandler +from .message.converter import MessageConverter from .platform_detector import detect_platform +from .session.session_manager import SessionManager from .socket_factory import create_socket_server @@ -37,25 +41,22 @@ "CLI测试器，用于快速测试和调试插件，构建快速反馈循环", default_config_tmpl={ "type": "cli", - "enable": False, # 默认关闭，开发时手动启用 - "mode": "socket", # 默认使用Socket模式 - "socket_type": "auto", # Socket类型: "auto"(自动检测) | "unix" | "tcp" - "socket_path": None, # Unix Socket路径，None表示使用动态路径 - "tcp_host": "127.0.0.1", # TCP Socket监听地址 - "tcp_port": 0, # TCP Socket监听端口，0表示随机端口 - "whitelist": [], # 空白名单表示允许所有 - "use_isolated_sessions": False, # 是否启用会话隔离（每个请求独立会话） - "session_ttl": 30, # 会话过期时间（秒），仅在use_isolated_sessions=True时生效，测试用30秒，生产建议1800秒（30分钟） + "enable": False, + "mode": "socket", + "socket_type": "auto", + "socket_path": None, + "tcp_host": "127.0.0.1", + "tcp_port": 0, + "whitelist": [], + "use_isolated_sessions": False, + "session_ttl": 30, }, support_streaming_message=False, ) class CLIPlatformAdapter(Platform): - """CLI测试器 - - 提供命令行交互界面，用于快速测试和调试插件。 + """CLI平台适配器 - 编排层 - 数据流管道: - 用户输入 → convert_input → AstrBotMessage → handle_msg → commit_event + 通过组合各模块实现CLI测试功能。 """ def __init__( @@ -64,834 +65,139 @@ def __init__( platform_settings: dict, event_queue: asyncio.Queue, ) -> None: - """初始化CLI平台适配器 - - Args: - platform_config: 平台配置 - platform_settings: 平台设置 - event_queue: 事件队列 - """ + """初始化CLI平台适配器""" super().__init__(platform_config, event_queue) - # 尝试从独立配置文件加载CLI配置 - import json - import os - - config_file = platform_config.get("config_file", "cli_config.json") - cli_config_path = os.path.join(get_astrbot_data_path(), config_file) - if os.path.exists(cli_config_path): - try: - with open(cli_config_path, encoding="utf-8") as f: - cli_config = json.load(f) - # 使用独立配置文件中的配置覆盖传入的参数 - if "platform_config" in cli_config: - platform_config.update(cli_config["platform_config"]) - if "platform_settings" in cli_config: - platform_settings = cli_config["platform_settings"] - logger.info("[PROCESS] Loaded CLI config from %s", cli_config_path) - except Exception as e: - logger.warning( - "[WARN] Failed to load CLI config from %s: %s", cli_config_path, e - ) - - logger.info( - "[ENTRY] CLIPlatformAdapter.__init__ inputs={config=%s}", platform_config - ) - - self.settings = platform_settings - self.session_id = "cli_session" - self.user_id = "cli_user" - self.user_nickname = "CLI User" - - # 运行模式配置 - self.mode = platform_config.get( - "mode", "auto" - ) # "auto", "tty", "file", "socket" - - # 文件I/O配置 - self.input_file = platform_config.get( - "input_file", - os.path.join(get_astrbot_temp_path(), "astrbot_cli", "input.txt"), - ) - self.output_file = platform_config.get( - "output_file", - os.path.join(get_astrbot_temp_path(), "astrbot_cli", "output.txt"), - ) - self.poll_interval = platform_config.get("poll_interval", 1.0) + # 加载配置 + self.config = ConfigLoader.load(platform_config, platform_settings) - # Socket配置（跨平台） - self.socket_type = platform_config.get("socket_type", "auto") - self.socket_path = platform_config.get( - "socket_path", os.path.join(get_astrbot_temp_path(), "astrbot.sock") + # 初始化各模块 + self.token_manager = TokenManager() + self.session_manager = SessionManager( + ttl=self.config.session_ttl, + enabled=self.config.use_isolated_sessions, ) - self.tcp_host = platform_config.get("tcp_host", "127.0.0.1") - self.tcp_port = platform_config.get("tcp_port", 0) - - # Token认证配置 - self.auth_token = self._ensure_auth_token() - - # 会话隔离配置 - self.use_isolated_sessions = platform_config.get("use_isolated_sessions", False) - self.session_ttl = platform_config.get( - "session_ttl", 30 - ) # 默认30秒（测试），生产建议1800秒 + self.message_converter = MessageConverter() + # 平台元数据 self.metadata = PlatformMetadata( name="cli", description="命令行模拟器", - id=platform_config.get("id", "cli"), + id=self.config.platform_id, support_streaming_message=False, ) + # 运行状态 self._running = False self._output_queue: asyncio.Queue = asyncio.Queue() + self._handler = None - # 会话过期跟踪（仅在use_isolated_sessions=True时使用） - self._session_timestamps: dict[str, float] = {} # {session_id: timestamp} - self._cleanup_task: asyncio.Task | None = None - - logger.info("[EXIT] CLIPlatformAdapter.__init__ return=None") + logger.info("[CLI] Adapter initialized, mode=%s", self.config.mode) def run(self) -> Awaitable[Any]: - """启动CLI平台 - - Returns: - 协程对象，用于异步运行 - """ - logger.info("[ENTRY] CLIPlatformAdapter.run inputs={}") + """启动CLI平台""" return self._run_loop() - def _ensure_auth_token(self) -> str | None: - """[原子模块] TokenManager: 确保认证token存在,不存在则自动生成 - - I/O契约: - Input: None - Output: str | None (token字符串或None) - """ - import os - import secrets - - token_file = os.path.join(get_astrbot_data_path(), ".cli_token") - - logger.debug("[ENTRY] _ensure_auth_token inputs={}") - - try: - # 如果token文件已存在,直接读取 - if os.path.exists(token_file): - with open(token_file, encoding="utf-8") as f: - token = f.read().strip() - - if token: - logger.info("[SECURITY] Authentication token loaded from file") - logger.debug( - "[EXIT] _ensure_auth_token return={token_length=%d}", len(token) - ) - return token - else: - logger.warning("[SECURITY] Token file is empty, regenerating") - - # 首次启动或token为空,自动生成新token - token = secrets.token_urlsafe(32) - - # 写入文件 - with open(token_file, "w", encoding="utf-8") as f: - f.write(token) - - # 设置严格权限(仅所有者可读写) - os.chmod(token_file, 0o600) - - logger.info("[SECURITY] Generated new authentication token: %s", token) - logger.info("[SECURITY] Token saved to: %s (permissions: 600)", token_file) - logger.debug( - "[EXIT] _ensure_auth_token return={token_length=%d}", len(token) - ) - return token - - except Exception as e: - logger.error("[ERROR] Failed to ensure token: %s", e) - logger.warning("[SECURITY] Authentication disabled due to token error") - return None - async def _run_loop(self) -> None: - """主运行循环 - - 管道流程: - 1. 读取用户输入 (InputReader) - 2. 转换为消息对象 (MessageConverter) - 3. 处理消息事件 (EventHandler) - 4. 输出响应 (OutputWriter) - """ - logger.info("[PROCESS] Starting CLI loop") - - # 启动会话清理任务（仅在use_isolated_sessions=True时） - if self.use_isolated_sessions: - self._cleanup_task = asyncio.create_task(self._cleanup_expired_sessions()) - logger.info("[PROCESS] Session cleanup task started") - - # 决定运行模式 - has_tty = sys.stdin.isatty() - - # Socket模式优先 - if self.mode == "socket": - logger.info("[PROCESS] Starting Unix Socket mode") - await self._run_socket_mode() - return - - # 其他模式 - if self.mode == "auto": - # 自动模式：有TTY用交互，无TTY用文件 - use_file_mode = not has_tty - elif self.mode == "file": - use_file_mode = True - elif self.mode == "tty": - use_file_mode = False - if not has_tty: - logger.warning( - "[PROCESS] TTY mode requested but no TTY detected. " - "CLI platform will not start." - ) - return - else: - logger.error(f"[ERROR] Unknown mode: {self.mode}") - return - - if use_file_mode: - logger.info("[PROCESS] Starting file polling mode") - await self._run_file_mode() - else: - logger.info("[PROCESS] Starting TTY interactive mode") - await self._run_tty_mode() - - async def _run_tty_mode(self) -> None: - """TTY交互模式""" + """主运行循环 - 根据模式选择Handler""" self._running = True - print("\n" + "=" * 60) - print("AstrBot CLI Simulator") - print("=" * 60) - print("Type your message and press Enter to send.") - print("Type 'exit' or 'quit' to stop.") - print("=" * 60 + "\n") - - # 启动输出监听器 - output_task = asyncio.create_task(self._output_monitor("tty")) + # 启动会话清理任务 + self.session_manager.start_cleanup_task() try: - while self._running: - # [原子模块1] InputReader: 读取用户输入 - user_input = await self._read_input() - - if not user_input: - continue - - # 处理退出命令 - if user_input.lower() in ["exit", "quit"]: - logger.info("[PROCESS] User requested exit") - break - - # [原子模块2] MessageConverter: 转换为AstrBotMessage - message = self._convert_input(user_input) - - # [原子模块3] EventHandler: 处理消息 - await self._handle_msg(message) - - except KeyboardInterrupt: - logger.info("[PROCESS] Received KeyboardInterrupt") - finally: - self._running = False - output_task.cancel() - logger.info("[EXIT] CLIPlatformAdapter._run_tty_mode return=None") - - async def _run_file_mode(self) -> None: - """文件轮询模式""" - import os - - self._running = True - - # 确保目录存在 - os.makedirs(os.path.dirname(self.input_file), exist_ok=True) - os.makedirs(os.path.dirname(self.output_file), exist_ok=True) - - # 创建输入文件（如果不存在） - if not os.path.exists(self.input_file): - with open(self.input_file, "w") as f: - f.write("") - - logger.info("[PROCESS] File mode started") - logger.info(f"[PROCESS] Input file: {self.input_file}") - logger.info(f"[PROCESS] Output file: {self.output_file}") - logger.info(f"[PROCESS] Poll interval: {self.poll_interval}s") - - # 启动输出监听器 - output_task = asyncio.create_task(self._output_monitor("file")) - - try: - while self._running: - # 读取输入文件 - commands = await self._read_from_file() - - for cmd in commands: - if not cmd: - continue - - logger.info(f"[PROCESS] Processing command: {cmd}") - - # 转换并处理消息 - message = self._convert_input(cmd) - await self._handle_msg(message) - - # 等待下一次轮询 - await asyncio.sleep(self.poll_interval) - - except Exception as e: - logger.error(f"[ERROR] File mode error: {e}") + # 根据模式创建并运行Handler + if self.config.mode == "socket": + await self._run_socket_mode() + elif self.config.mode == "tty": + await self._run_tty_mode() + elif self.config.mode == "file": + await self._run_file_mode() + else: + # auto模式：有TTY用交互，无TTY用socket + import sys + + if sys.stdin.isatty(): + await self._run_tty_mode() + else: + await self._run_socket_mode() finally: self._running = False - output_task.cancel() - logger.info("[EXIT] CLIPlatformAdapter._run_file_mode return=None") + await self.session_manager.stop_cleanup_task() async def _run_socket_mode(self) -> None: - """跨平台Socket服务器模式 - - 管道流程: - 平台检测 → 创建Socket服务器 → 写入连接信息 → 接受连接 → 处理请求 - """ - logger.info("[ENTRY] _run_socket_mode inputs={}") - - self._running = True - - # 检测平台信息 + """Socket模式""" platform_info = detect_platform() - logger.info( - "[PROCESS] Platform detected: os=%s, python=%s, unix_socket=%s", - platform_info.os_type, - platform_info.python_version, - platform_info.supports_unix_socket, + server = create_socket_server( + platform_info, + { + "socket_type": self.config.socket_type, + "socket_path": self.config.socket_path, + "tcp_host": self.config.tcp_host, + "tcp_port": self.config.tcp_port, + }, + self.token_manager.token, ) - # 创建Socket服务器（工厂模式） - config = { - "socket_type": self.socket_type, - "socket_path": self.socket_path, - "tcp_host": self.tcp_host, - "tcp_port": self.tcp_port, - } - server = create_socket_server(platform_info, config, self.auth_token) - logger.info("[PROCESS] Socket server created: %s", type(server).__name__) - - try: - # 启动服务器 - await server.start() - logger.info("[PROCESS] Socket server started") - - # 写入连接信息供客户端读取 - connection_info = server.get_connection_info() - write_connection_info(connection_info, get_astrbot_data_path()) - logger.info("[PROCESS] Connection info written: %s", connection_info) - - # 接受连接循环 - while self._running: - try: - client_socket, client_addr = await server.accept_connection() - logger.debug("[PROCESS] Client connected: %s", client_addr) - - # 处理连接（异步） - asyncio.create_task(self._handle_socket_client(client_socket)) - - except Exception as e: - logger.error("[ERROR] Socket accept error: %s", e) - await asyncio.sleep(0.1) - - except Exception as e: - logger.error("[ERROR] Socket mode error: %s", e) - finally: - self._running = False - await server.stop() - logger.info("[EXIT] _run_socket_mode return=None") - - async def _handle_socket_client(self, client_socket) -> None: - """[原子模块] SocketHandler: 处理单个socket客户端连接 - - I/O契约: - Input: socket连接 - Output: None (发送JSON响应到客户端) - """ - import json - - logger.debug("[ENTRY] _handle_socket_client") - - try: - loop = asyncio.get_running_loop() - - # 接收请求数据 - data = await loop.sock_recv(client_socket, 4096) - if not data: - logger.debug("[PROCESS] Empty request, closing connection") - return - - # 解析JSON请求 - try: - request = json.loads(data.decode("utf-8")) - message_text = request.get("message", "") - request_id = request.get("request_id", str(uuid.uuid4())) - auth_token = request.get("auth_token", "") - - logger.info( - f"[PROCESS] Received socket request: {message_text[:50]}..." - ) - - except json.JSONDecodeError as e: - logger.error(f"[ERROR] Invalid JSON request: {e}") - error_response = json.dumps( - {"status": "error", "error": "Invalid JSON format"} - ) - await loop.sock_sendall(client_socket, error_response.encode("utf-8")) - return - - # Token验证 - if self.auth_token: - if not auth_token: - logger.warning("[SECURITY] Request rejected: missing auth_token") - error_response = json.dumps( - {"status": "error", "error": "Unauthorized: missing token"} - ) - await loop.sock_sendall( - client_socket, error_response.encode("utf-8") - ) - return - - if auth_token != self.auth_token: - logger.warning( - "[SECURITY] Request rejected: invalid auth_token (length=%d)", - len(auth_token), - ) - error_response = json.dumps( - {"status": "error", "error": "Unauthorized: invalid token"} - ) - await loop.sock_sendall( - client_socket, error_response.encode("utf-8") - ) - return - - logger.debug("[SECURITY] Token validation passed") - - # 创建响应Future - response_future = asyncio.Future() - - # 转换并处理消息（传递request_id实现会话隔离） - message = self._convert_input(message_text, request_id=request_id) - - # 创建带response_future的事件 - message_event = CLIMessageEvent( - message_str=message.message_str, - message_obj=message, - platform_meta=self.meta(), - session_id=message.session_id, - output_queue=self._output_queue, - response_future=response_future, - ) - - # 提交事件 - self.commit_event(message_event) - - # 等待响应（超时30秒） - try: - message_chain = await asyncio.wait_for(response_future, timeout=30.0) - - # 提取文本 - response_text = message_chain.get_plain_text() - - # 提取图片 - from astrbot.core.message.components import Image - - images = [] - for comp in message_chain.chain: - if isinstance(comp, Image): - image_info = {} - if comp.file: - if comp.file.startswith("http"): - image_info["type"] = "url" - image_info["url"] = comp.file - elif comp.file.startswith("file:///"): - image_info["type"] = "file" - file_path = comp.file[8:] # 去掉 file:/// - image_info["path"] = file_path - - # 立即读取文件内容并转换为base64（避免临时文件被删除） - try: - import base64 - - with open(file_path, "rb") as f: - image_data = f.read() - base64_data = base64.b64encode( - image_data - ).decode("utf-8") - image_info["base64_data"] = base64_data - image_info["size"] = len(image_data) - logger.debug( - f"[PROCESS] Read image file: {file_path}, size: {len(image_data)} bytes" - ) - except Exception as e: - logger.error( - f"[ERROR] Failed to read image file {file_path}: {e}" - ) - image_info["error"] = str(e) - elif comp.file.startswith("base64://"): - # 将base64数据保存到临时文件，避免在JSON中暴露大量数据 - try: - import base64 - import os - import tempfile - - base64_data = comp.file[9:] - image_data = base64.b64decode(base64_data) - - # 生成临时文件路径 - temp_dir = get_astrbot_temp_path() - os.makedirs(temp_dir, exist_ok=True) - temp_file = tempfile.NamedTemporaryFile( - delete=False, - suffix=".png", - dir=temp_dir, - ) - temp_file.write(image_data) - temp_file.close() - - image_info["type"] = "file" - image_info["path"] = temp_file.name - image_info["size"] = len(image_data) - logger.debug( - f"[PROCESS] Saved base64 image to file: {temp_file.name}, size: {len(image_data)} bytes" - ) - except Exception as e: - logger.error( - f"[ERROR] Failed to save base64 image: {e}" - ) - image_info["type"] = "base64" - image_info["error"] = str(e) - image_info["base64_length"] = len(base64_data) - images.append(image_info) - - # 发送成功响应 - response = json.dumps( - { - "status": "success", - "response": response_text, - "images": images, - "request_id": request_id, - }, - ensure_ascii=False, - ) - - await loop.sock_sendall(client_socket, response.encode("utf-8")) - logger.info(f"[PROCESS] Sent response for request {request_id}") - - except asyncio.TimeoutError: - logger.error(f"[ERROR] Request {request_id} timeout") - error_response = json.dumps( - { - "status": "error", - "error": "Request timeout", - "request_id": request_id, - } - ) - await loop.sock_sendall(client_socket, error_response.encode("utf-8")) - - except Exception as e: - logger.error(f"[ERROR] Socket client handler error: {e}") - import traceback - - logger.error(traceback.format_exc()) - - finally: - client_socket.close() - logger.debug("[EXIT] _handle_socket_client return=None") - - async def _read_input(self) -> str: - """[原子模块] InputReader: 从命令行读取用户输入 - - I/O契约: - Input: None - Output: str (用户输入的文本) - """ - logger.debug("[ENTRY] _read_input inputs={}") - - # 使用asyncio在事件循环中运行阻塞的input() - loop = asyncio.get_running_loop() - user_input = await loop.run_in_executor(None, input, "You: ") - - logger.debug("[EXIT] _read_input return={input=%s}", user_input) - return user_input.strip() - - async def _read_from_file(self) -> list[str]: - """[原子模块] FileReader: 从文件读取命令 - - I/O契约: - Input: None - Output: list[str] (命令列表) - """ - import os - - try: - if not os.path.exists(self.input_file): - return [] - - # 读取文件内容 - with open(self.input_file, encoding="utf-8") as f: - content = f.read().strip() - - if not content: - return [] - - # 按行分割命令 - commands = [line.strip() for line in content.split("\n") if line.strip()] - - # 清空输入文件 - with open(self.input_file, "w", encoding="utf-8") as f: - f.write("") - - logger.debug(f"[EXIT] _read_from_file return={len(commands)} commands") - return commands - - except Exception as e: - logger.error(f"[ERROR] Failed to read from file: {e}") - return [] - - def _convert_input(self, text: str, request_id: str = None) -> AstrBotMessage: - """[原子模块] MessageConverter: 将文本转换为AstrBotMessage - - I/O契约: - Input: str (原始文本), request_id (可选，用于会话隔离) - Output: AstrBotMessage (标准消息对象) - """ - logger.debug( - "[ENTRY] _convert_input inputs={text=%s, request_id=%s}", text, request_id + client_handler = SocketClientHandler( + token_manager=self.token_manager, + message_converter=self.message_converter, + session_manager=self.session_manager, + platform_meta=self.metadata, + output_queue=self._output_queue, + event_committer=self.commit_event, + use_isolated_sessions=self.config.use_isolated_sessions, ) - message = AstrBotMessage() - message.self_id = "cli_bot" - message.message_str = text - message.message = [Plain(text)] # 使用Plain组件对象，而不是字典 - message.type = MessageType.FRIEND_MESSAGE - - # 添加message_id属性，避免插件访问时出错 - import uuid - - message.message_id = str(uuid.uuid4()) - - # 根据配置决定是否使用会话隔离 - if self.use_isolated_sessions and request_id: - # 启用会话隔离：每个请求独立会话 - session_id = f"cli_session_{request_id}" - message.session_id = session_id - - # 记录会话创建时间（用于过期清理） - import time - - if session_id not in self._session_timestamps: - self._session_timestamps[session_id] = time.time() - logger.debug( - f"[PROCESS] Created isolated session: {session_id}, TTL={self.session_ttl}s" - ) - else: - # 默认模式：使用固定会话ID - message.session_id = self.session_id - - message.sender = MessageMember( - user_id=self.user_id, - nickname=self.user_nickname, + self._handler = SocketModeHandler( + server=server, + client_handler=client_handler, + connection_info_writer=write_connection_info, + data_path=get_astrbot_data_path(), ) - logger.debug("[EXIT] _convert_input return={message=%s}", message) - return message - - async def _handle_msg(self, message: AstrBotMessage) -> None: - """[原子模块] EventHandler: 处理消息并提交事件 + await self._handler.run() - I/O契约: - Input: AstrBotMessage - Output: None (提交到事件队列) - """ - logger.debug("[ENTRY] _handle_msg inputs={message=%s}", message.message_str) - - # 创建消息事件 - message_event = CLIMessageEvent( - message_str=message.message_str, - message_obj=message, - platform_meta=self.meta(), - session_id=message.session_id, + async def _run_tty_mode(self) -> None: + """TTY交互模式""" + self._handler = TTYHandler( + message_converter=self.message_converter, + platform_meta=self.metadata, output_queue=self._output_queue, + event_committer=self.commit_event, ) + await self._handler.run() - logger.info( - "[PROCESS] Committing event to queue: session_id=%s", message.session_id + async def _run_file_mode(self) -> None: + """文件轮询模式""" + self._handler = FileHandler( + input_file=self.config.input_file, + output_file=self.config.output_file, + poll_interval=self.config.poll_interval, + message_converter=self.message_converter, + platform_meta=self.metadata, + output_queue=self._output_queue, + event_committer=self.commit_event, ) - - # 提交到事件队列 - self.commit_event(message_event) - - logger.debug("[EXIT] _handle_msg return=None") - - async def _output_monitor(self, mode: str = "tty") -> None: - """[原子模块] ResponseMonitor: 监听响应队列并输出 - - I/O契约: - Input: MessageChain (从响应队列) - Output: None (输出到stdout或文件) - - Args: - mode: 输出模式，"tty"或"file" - """ - logger.debug(f"[ENTRY] _output_monitor inputs={{mode={mode}}}") - - while self._running: - try: - # 从输出队列获取响应 - message_chain = await asyncio.wait_for( - self._output_queue.get(), timeout=0.5 - ) - - # 根据模式选择输出方式 - if mode == "file": - await self._write_to_file(message_chain) - else: - self._write_output(message_chain) - - except asyncio.TimeoutError: - continue - except Exception as e: - logger.error("[ERROR] Output monitor error: %s", e) - - logger.debug("[EXIT] _output_monitor return=None") - - def _write_output(self, message_chain: MessageChain) -> None: - """[原子模块] OutputWriter: 将消息输出到命令行 - - I/O契约: - Input: MessageChain - Output: None (打印到stdout) - """ - logger.debug("[ENTRY] _write_output inputs={message_chain=%s}", message_chain) - - print(f"\nBot: {message_chain.get_plain_text()}\n") - - logger.debug("[EXIT] _write_output return=None") - - async def _write_to_file(self, message_chain: MessageChain) -> None: - """[原子模块] FileWriter: 将消息输出到文件 - - I/O契约: - Input: MessageChain - Output: None (写入文件) - """ - import datetime - - logger.debug("[ENTRY] _write_to_file inputs={message_chain=%s}", message_chain) - - try: - # 获取消息文本 - text = message_chain.get_plain_text() - - # 添加时间戳 - timestamp = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S") - output_line = f"[{timestamp}] Bot: {text}\n" - - # 追加到输出文件 - with open(self.output_file, "a", encoding="utf-8") as f: - f.write(output_line) - - logger.info(f"[PROCESS] Output written to file: {self.output_file}") - - except Exception as e: - logger.error(f"[ERROR] Failed to write to file: {e}") - - logger.debug("[EXIT] _write_to_file return=None") + await self._handler.run() async def send_by_session( self, session: MessageSesion, message_chain: MessageChain, ) -> None: - """通过会话发送消息 - - Args: - session: 消息会话 - message_chain: 消息链 - """ - logger.debug("[ENTRY] send_by_session inputs={session=%s}", session) - - # 将消息放入输出队列 + """通过会话发送消息""" await self._output_queue.put(message_chain) - await super().send_by_session(session, message_chain) - logger.debug("[EXIT] send_by_session return=None") - def meta(self) -> PlatformMetadata: - """获取平台元数据 - - Returns: - 平台元数据 - """ + """获取平台元数据""" return self.metadata - async def _cleanup_expired_sessions(self) -> None: - """[后台任务] 定期清理过期的会话记录 - - 仅在use_isolated_sessions=True时运行。 - 定期检查_session_timestamps，删除过期的会话记录。 - """ - import time - - logger.info( - "[ENTRY] _cleanup_expired_sessions started, TTL=%s seconds", - self.session_ttl, - ) - - while self._running: - try: - await asyncio.sleep(10) # 每10秒检查一次 - - if not self.use_isolated_sessions: - continue - - current_time = time.time() - expired_sessions = [] - - # 找出过期的会话 - for session_id, timestamp in list(self._session_timestamps.items()): - if current_time - timestamp > self.session_ttl: - expired_sessions.append(session_id) - - # 清理过期会话 - for session_id in expired_sessions: - logger.info(f"[PROCESS] Cleaning expired session: {session_id}") - self._session_timestamps.pop(session_id, None) - - # TODO: 从数据库删除会话记录（如果需要） - # await self.context.db.delete_platform_session(session_id) - - if expired_sessions: - logger.info( - f"[PROCESS] Cleaned {len(expired_sessions)} expired sessions" - ) - - except Exception as e: - logger.error(f"[ERROR] Session cleanup error: {e}") - - logger.info("[EXIT] _cleanup_expired_sessions stopped") - async def terminate(self) -> None: """终止平台运行""" - logger.info("[ENTRY] CLIPlatformAdapter.terminate inputs={}") self._running = False - - # 停止清理任务 - if self._cleanup_task and not self._cleanup_task.done(): - self._cleanup_task.cancel() - try: - await self._cleanup_task - except asyncio.CancelledError: - logger.info("[PROCESS] Cleanup task cancelled") - - logger.info("[EXIT] CLIPlatformAdapter.terminate return=None") + if self._handler: + self._handler.stop() + await self.session_manager.stop_cleanup_task() + logger.info("[CLI] Adapter terminated") diff --git a/astrbot/core/platform/sources/cli/cli_event.py b/astrbot/core/platform/sources/cli/cli_event.py index c6125562be..5c6eaecb1d 100644 --- a/astrbot/core/platform/sources/cli/cli_event.py +++ b/astrbot/core/platform/sources/cli/cli_event.py @@ -2,18 +2,20 @@ CLI Message Event - CLI消息事件 处理CLI平台的消息事件，包括消息发送和接收。 +使用 ImageProcessor 处理图片，遵循 DRY 原则。 """ import asyncio from typing import Any from astrbot import logger -from astrbot.core.message.components import Plain from astrbot.core.message.message_event_result import MessageChain from astrbot.core.platform.astr_message_event import AstrMessageEvent from astrbot.core.platform.astrbot_message import AstrBotMessage from astrbot.core.platform.platform_metadata import PlatformMetadata +from .message.image_processor import ImageProcessor + class CLIMessageEvent(AstrMessageEvent): """CLI消息事件 @@ -21,6 +23,11 @@ class CLIMessageEvent(AstrMessageEvent): 处理命令行模拟器的消息事件。 """ + # 延迟配置 + INITIAL_DELAY = 5.0 # 首次发送延迟 + EXTENDED_DELAY = 10.0 # 后续发送延迟 + MAX_BUFFER_SIZE = 100 # 缓冲区最大消息组件数 + def __init__( self, message_str: str, @@ -30,16 +37,7 @@ def __init__( output_queue: asyncio.Queue, response_future: asyncio.Future = None, ): - """初始化CLI消息事件 - - Args: - message_str: 纯文本消息 - message_obj: 消息对象 - platform_meta: 平台元数据 - session_id: 会话ID - output_queue: 输出队列 - response_future: 响应Future对象（用于socket模式） - """ + """初始化CLI消息事件""" super().__init__( message_str=message_str, message_obj=message_obj, @@ -47,131 +45,78 @@ def __init__( session_id=session_id, ) - logger.debug("[ENTRY] CLIMessageEvent.__init__ inputs={message_str=%s}", message_str) - self.output_queue = output_queue self.response_future = response_future - # 用于收集多次回复 + # 多次回复收集 self.send_buffer = None self._response_delay_task = None - self._response_delay = 3.0 # 延迟3秒收集所有回复（支持工具调用等多轮场景） - - logger.debug("[EXIT] CLIMessageEvent.__init__ return=None") + self._response_delay = self.INITIAL_DELAY async def send(self, message_chain: MessageChain) -> dict[str, Any]: - """发送消息到CLI - - Args: - message_chain: 消息链 - - Returns: - 发送结果 - """ - logger.debug("[ENTRY] CLIMessageEvent.send inputs={message_chain=%s}", message_chain) - + """发送消息到CLI""" # Socket模式：收集多次回复 if self.response_future is not None and not self.response_future.done(): - # 预处理本地文件图片：立即读取并转换为base64（避免临时文件被删除） - from astrbot.core.message.components import Image - import base64 - import os - - for comp in message_chain.chain: - if isinstance(comp, Image) and comp.file and comp.file.startswith("file:///"): - file_path = comp.file[8:] # 去掉 file:/// - try: - if os.path.exists(file_path): - with open(file_path, 'rb') as f: - image_data = f.read() - base64_data = base64.b64encode(image_data).decode('utf-8') - # 修改Image组件，将本地文件转换为base64 - comp.file = f"base64://{base64_data}" - logger.debug(f"[PROCESS] Converted local image to base64: {file_path}, size: {len(image_data)} bytes") - except Exception as e: - logger.error(f"[ERROR] Failed to read image file {file_path}: {e}") - - # 收集多次回复到buffer（自适应延迟机制） + # 使用 ImageProcessor 预处理图片（避免临时文件被删除） + ImageProcessor.preprocess_chain(message_chain) + + # 收集多次回复到buffer if not self.send_buffer: - # 第一次send：初始化buffer，使用中等延迟（5秒） - # 5秒足够等待工具调用的第二次回复，同时不会让简单回复等太久 self.send_buffer = message_chain - self._response_delay = 5.0 - logger.info("[PROCESS] First send: initialized buffer with 5s delay") + self._response_delay = self.INITIAL_DELAY + logger.debug("[CLI] First send: buffer initialized") else: - # 后续send：追加到buffer，切换到长延迟（10秒） - # 确保能收集到所有工具调用的回复 - self.send_buffer.chain.extend(message_chain.chain) - self._response_delay = 10.0 - logger.info( - f"[PROCESS] Appended to buffer (switched to 10s delay), total: {len(self.send_buffer.chain)} components" + # 检查缓冲区大小限制 + current_size = len(self.send_buffer.chain) + new_size = len(message_chain.chain) + if current_size + new_size > self.MAX_BUFFER_SIZE: + logger.warning( + "[CLI] Buffer size limit reached (%d + %d > %d), truncating", + current_size, + new_size, + self.MAX_BUFFER_SIZE, + ) + # 只添加能容纳的部分 + available = self.MAX_BUFFER_SIZE - current_size + if available > 0: + self.send_buffer.chain.extend(message_chain.chain[:available]) + else: + self.send_buffer.chain.extend(message_chain.chain) + self._response_delay = self.EXTENDED_DELAY + logger.debug( + "[CLI] Appended to buffer, total: %d", len(self.send_buffer.chain) ) - # 取消之前的延迟任务（如果存在） + # 重置延迟任务 if self._response_delay_task and not self._response_delay_task.done(): self._response_delay_task.cancel() - logger.info("[PROCESS] Cancelled previous delay task") - # 启动新的延迟任务（每次send都重置延迟） self._response_delay_task = asyncio.create_task(self._delayed_response()) - logger.info(f"[PROCESS] Started new delay task ({self._response_delay}s)") else: - # 其他模式：将消息放入输出队列 + # 其他模式：直接放入输出队列 await self.output_queue.put(message_chain) - logger.debug("[PROCESS] Put message to output queue") - - logger.debug("[EXIT] CLIMessageEvent.send return={success=True}") return {"success": True} async def reply(self, message_chain: MessageChain) -> dict[str, Any]: - """回复消息 - - Args: - message_chain: 消息链 - - Returns: - 发送结果 - """ - logger.debug("[ENTRY] CLIMessageEvent.reply inputs={message_chain=%s}", message_chain) - - result = await self.send(message_chain) - - logger.debug("[EXIT] CLIMessageEvent.reply return=%s", result) - - return result + """回复消息""" + return await self.send(message_chain) async def _delayed_response(self) -> None: - """延迟响应：等待一段时间收集所有回复后统一返回 - - 等待 _response_delay 秒后，将累积的所有消息统一返回给客户端。 - 这样可以支持插件的多轮回复（如先发文本，再发图片）。 - """ - logger.debug( - "[ENTRY] _delayed_response inputs={delay=%s}", self._response_delay - ) - + """延迟响应：收集所有回复后统一返回""" try: - # 等待延迟时间，收集所有回复 await asyncio.sleep(self._response_delay) - # 检查 Future 是否还未完成 if self.response_future and not self.response_future.done(): - # 将累积的消息设置到 Future self.response_future.set_result(self.send_buffer) logger.debug( - "[PROCESS] Set delayed response with %d components", + "[CLI] Delayed response set, %d components", len(self.send_buffer.chain), ) - else: - logger.warning( - "[WARN] Response future already done or None, skipping set_result" - ) + except asyncio.CancelledError: + pass except Exception as e: - logger.error("[ERROR] Failed to set delayed response: %s", e) - # 如果出错，尝试设置异常到 Future + logger.error("[CLI] Delayed response error: %s", e) if self.response_future and not self.response_future.done(): self.response_future.set_exception(e) - - logger.debug("[EXIT] _delayed_response return=None") diff --git a/astrbot/core/platform/sources/cli/config/__init__.py b/astrbot/core/platform/sources/cli/config/__init__.py new file mode 100644 index 0000000000..d026e8ee9c --- /dev/null +++ b/astrbot/core/platform/sources/cli/config/__init__.py @@ -0,0 +1,6 @@ +"""CLI配置模块""" + +from .config_loader import ConfigLoader +from .token_manager import TokenManager + +__all__ = ["ConfigLoader", "TokenManager"] diff --git a/astrbot/core/platform/sources/cli/config/config_loader.py b/astrbot/core/platform/sources/cli/config/config_loader.py new file mode 100644 index 0000000000..9a9da6efc5 --- /dev/null +++ b/astrbot/core/platform/sources/cli/config/config_loader.py @@ -0,0 +1,224 @@ +"""CLI配置模块 + +拆分为单一职责的小组件： +- CLIConfig: 纯数据结构 +- PathResolver: 路径解析 +- ConfigFileReader: 配置文件读取 +- ConfigLoader: 组合门面 +""" + +import json +import os +from dataclasses import dataclass, field +from typing import Any + +from astrbot import logger +from astrbot.core.utils.astrbot_path import get_astrbot_data_path, get_astrbot_temp_path + +# ============================================================ +# 原子组件：路径解析器 +# ============================================================ + + +class PathResolver: + """路径解析器 + + 单一职责：解析和生成默认路径 + """ + + @staticmethod + def get_socket_path(custom_path: str = "") -> str: + """获取Socket路径""" + if custom_path: + return custom_path + return os.path.join(get_astrbot_temp_path(), "astrbot.sock") + + @staticmethod + def get_input_file(custom_path: str = "") -> str: + """获取输入文件路径""" + if custom_path: + return custom_path + return os.path.join(get_astrbot_temp_path(), "astrbot_cli", "input.txt") + + @staticmethod + def get_output_file(custom_path: str = "") -> str: + """获取输出文件路径""" + if custom_path: + return custom_path + return os.path.join(get_astrbot_temp_path(), "astrbot_cli", "output.txt") + + @staticmethod + def get_config_file_path(filename: str = "cli_config.json") -> str: + """获取配置文件路径""" + return os.path.join(get_astrbot_data_path(), filename) + + +# ============================================================ +# 原子组件：配置文件读取器 +# ============================================================ + + +class ConfigFileReader: + """配置文件读取器 + + 单一职责：读取JSON配置文件 + """ + + @staticmethod + def read(file_path: str) -> dict | None: + """读取配置文件 + + Args: + file_path: 配置文件路径 + + Returns: + 配置字典或None + """ + if not os.path.exists(file_path): + return None + + try: + with open(file_path, encoding="utf-8") as f: + config = json.load(f) + logger.info("Loaded config from %s", file_path) + return config + except Exception as e: + logger.warning("Failed to load config from %s: %s", file_path, e) + return None + + +# ============================================================ +# 数据结构：CLI配置 +# ============================================================ + + +@dataclass +class CLIConfig: + """CLI配置数据类 + + 纯数据结构，不包含业务逻辑 + """ + + # 运行模式 + mode: str = "socket" + socket_type: str = "auto" + socket_path: str = "" + tcp_host: str = "127.0.0.1" + tcp_port: int = 0 + + # 文件模式配置 + input_file: str = "" + output_file: str = "" + poll_interval: float = 1.0 + + # 会话配置 + use_isolated_sessions: bool = False + session_ttl: int = 30 + + # 其他 + whitelist: list[str] = field(default_factory=list) + platform_id: str = "cli" + + +# ============================================================ +# 组合组件：配置构建器 +# ============================================================ + + +class ConfigBuilder: + """配置构建器 + + 从字典构建CLIConfig，处理默认值 + """ + + @staticmethod + def build(config_dict: dict[str, Any]) -> CLIConfig: + """从字典构建配置""" + return CLIConfig( + mode=config_dict.get("mode", "socket"), + socket_type=config_dict.get("socket_type", "auto"), + socket_path=PathResolver.get_socket_path( + config_dict.get("socket_path", "") + ), + tcp_host=config_dict.get("tcp_host", "127.0.0.1"), + tcp_port=config_dict.get("tcp_port", 0), + input_file=PathResolver.get_input_file(config_dict.get("input_file", "")), + output_file=PathResolver.get_output_file( + config_dict.get("output_file", "") + ), + poll_interval=config_dict.get("poll_interval", 1.0), + use_isolated_sessions=config_dict.get("use_isolated_sessions", False), + session_ttl=config_dict.get("session_ttl", 30), + whitelist=config_dict.get("whitelist", []), + platform_id=config_dict.get("id", "cli"), + ) + + +# ============================================================ +# 组合组件：配置合并器 +# ============================================================ + + +class ConfigMerger: + """配置合并器 + + 合并多个配置源 + """ + + @staticmethod + def merge(base: dict, override: dict | None) -> dict: + """合并配置，override优先""" + if override is None: + return base.copy() + + result = base.copy() + result.update(override) + return result + + +# ============================================================ +# 门面：配置加载器 +# ============================================================ + + +class ConfigLoader: + """配置加载器门面 + + 组合所有小组件，提供统一接口 + + I/O契约: + Input: platform_config (dict), platform_settings (dict) + Output: CLIConfig + """ + + @staticmethod + def load( + platform_config: dict[str, Any], + platform_settings: dict[str, Any] | None = None, + ) -> CLIConfig: + """加载CLI配置 + + 优先级: 独立配置文件 > platform_config > 默认值 + + Args: + platform_config: 平台配置字典 + platform_settings: 平台设置字典 + + Returns: + CLIConfig实例 + """ + # 尝试从独立配置文件加载 + config_filename = platform_config.get("config_file", "cli_config.json") + config_path = PathResolver.get_config_file_path(config_filename) + + file_config = ConfigFileReader.read(config_path) + + # 合并配置 + if file_config: + if "platform_config" in file_config: + platform_config = ConfigMerger.merge( + platform_config, file_config["platform_config"] + ) + + # 构建最终配置 + return ConfigBuilder.build(platform_config) diff --git a/astrbot/core/platform/sources/cli/config/token_manager.py b/astrbot/core/platform/sources/cli/config/token_manager.py new file mode 100644 index 0000000000..e2708e7fe8 --- /dev/null +++ b/astrbot/core/platform/sources/cli/config/token_manager.py @@ -0,0 +1,99 @@ +"""Token管理器 + +负责认证Token的生成、读取和验证。 +""" + +import os +import secrets + +from astrbot import logger +from astrbot.core.utils.astrbot_path import get_astrbot_data_path + + +class TokenManager: + """Token管理器 + + I/O契约: + Input: None + Output: token (str | None) + """ + + TOKEN_FILE = ".cli_token" + + def __init__(self): + """初始化Token管理器""" + self._token: str | None = None + self._token_file = os.path.join(get_astrbot_data_path(), self.TOKEN_FILE) + + @property + def token(self) -> str | None: + """获取当前Token""" + if self._token is None: + self._token = self._ensure_token() + return self._token + + def _ensure_token(self) -> str | None: + """确保Token存在，不存在则自动生成 + + Returns: + Token字符串或None + """ + try: + # 如果token文件已存在，直接读取 + if os.path.exists(self._token_file): + with open(self._token_file, encoding="utf-8") as f: + token = f.read().strip() + + if token: + logger.info("Authentication token loaded from file") + return token + else: + logger.warning("Token file is empty, regenerating") + + # 首次启动或token为空，自动生成新token + token = secrets.token_urlsafe(32) + + # 写入文件 + with open(self._token_file, "w", encoding="utf-8") as f: + f.write(token) + + # 设置严格权限（仅所有者可读写） + try: + os.chmod(self._token_file, 0o600) + except OSError: + # Windows可能不支持chmod + pass + + logger.info("Generated new authentication token: %s", token) + logger.info("Token saved to: %s", self._token_file) + return token + + except Exception as e: + logger.error("Failed to ensure token: %s", e) + logger.warning("Authentication disabled due to token error") + return None + + def validate(self, provided_token: str) -> bool: + """验证提供的Token + + Args: + provided_token: 待验证的Token + + Returns: + 验证是否通过 + """ + if not self.token: + # 无Token时跳过验证 + return True + + if not provided_token: + logger.warning("Request rejected: missing auth_token") + return False + + if provided_token != self.token: + logger.warning( + "Request rejected: invalid auth_token (length=%d)", len(provided_token) + ) + return False + + return True diff --git a/astrbot/core/platform/sources/cli/handlers/__init__.py b/astrbot/core/platform/sources/cli/handlers/__init__.py new file mode 100644 index 0000000000..b4b9d0b409 --- /dev/null +++ b/astrbot/core/platform/sources/cli/handlers/__init__.py @@ -0,0 +1,7 @@ +"""CLI处理器模块""" + +from .file_handler import FileHandler +from .socket_handler import SocketClientHandler, SocketModeHandler +from .tty_handler import TTYHandler + +__all__ = ["SocketClientHandler", "SocketModeHandler", "TTYHandler", "FileHandler"] diff --git a/astrbot/core/platform/sources/cli/handlers/file_handler.py b/astrbot/core/platform/sources/cli/handlers/file_handler.py new file mode 100644 index 0000000000..d10fee2c0a --- /dev/null +++ b/astrbot/core/platform/sources/cli/handlers/file_handler.py @@ -0,0 +1,159 @@ +"""文件轮询模式处理器 + +负责处理文件轮询模式的输入输出。 +""" + +import asyncio +import datetime +import os +from collections.abc import Callable +from typing import TYPE_CHECKING + +from astrbot import logger +from astrbot.core.message.message_event_result import MessageChain + +from ..interfaces import IHandler, IMessageConverter + +if TYPE_CHECKING: + from astrbot.core.platform.platform_metadata import PlatformMetadata + + from ..cli_event import CLIMessageEvent + + +class FileHandler(IHandler): + """文件轮询模式处理器 + + 实现IHandler接口，提供文件I/O功能。 + + I/O契约: + Input: 输入文件内容 + Output: None (写入输出文件) + """ + + def __init__( + self, + input_file: str, + output_file: str, + poll_interval: float, + message_converter: IMessageConverter, + platform_meta: "PlatformMetadata", + output_queue: asyncio.Queue, + event_committer: Callable[["CLIMessageEvent"], None], + ): + """初始化文件处理器""" + self.input_file = input_file + self.output_file = output_file + self.poll_interval = poll_interval + self.message_converter = message_converter + self.platform_meta = platform_meta + self.output_queue = output_queue + self.event_committer = event_committer + self._running = False + + async def run(self) -> None: + """运行文件轮询模式""" + self._running = True + self._ensure_directories() + + logger.info("File mode: input=%s, output=%s", self.input_file, self.output_file) + + output_task = asyncio.create_task(self._output_loop()) + + try: + await self._poll_loop() + finally: + self._running = False + output_task.cancel() + try: + await output_task + except asyncio.CancelledError: + pass + + def stop(self) -> None: + """停止文件模式""" + self._running = False + + def _ensure_directories(self) -> None: + """确保目录存在""" + for path in (self.input_file, self.output_file): + dir_path = os.path.dirname(path) + if dir_path: + os.makedirs(dir_path, exist_ok=True) + + if not os.path.exists(self.input_file): + with open(self.input_file, "w") as f: + f.write("") + + async def _poll_loop(self) -> None: + """轮询循环""" + while self._running: + commands = self._read_commands() + + for cmd in commands: + if cmd: + await self._handle_command(cmd) + + await asyncio.sleep(self.poll_interval) + + def _read_commands(self) -> list[str]: + """读取并清空输入文件""" + try: + if not os.path.exists(self.input_file): + return [] + + with open(self.input_file, encoding="utf-8") as f: + content = f.read().strip() + + if not content: + return [] + + # 清空输入文件 + with open(self.input_file, "w", encoding="utf-8") as f: + f.write("") + + return [line.strip() for line in content.split("\n") if line.strip()] + + except Exception as e: + logger.error("Failed to read input file: %s", e) + return [] + + async def _handle_command(self, text: str) -> None: + """处理命令""" + from ..cli_event import CLIMessageEvent + + message = self.message_converter.convert(text) + + message_event = CLIMessageEvent( + message_str=message.message_str, + message_obj=message, + platform_meta=self.platform_meta, + session_id=message.session_id, + output_queue=self.output_queue, + ) + + self.event_committer(message_event) + + async def _output_loop(self) -> None: + """输出循环""" + while self._running: + try: + message_chain = await asyncio.wait_for( + self.output_queue.get(), timeout=0.5 + ) + self._write_response(message_chain) + except asyncio.TimeoutError: + continue + except asyncio.CancelledError: + break + + def _write_response(self, message_chain: MessageChain) -> None: + """写入响应到文件""" + try: + text = message_chain.get_plain_text() + timestamp = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S") + + with open(self.output_file, "a", encoding="utf-8") as f: + f.write(f"[{timestamp}] Bot: {text}\n") + + except Exception as e: + logger.error("Failed to write output file: %s", e) diff --git a/astrbot/core/platform/sources/cli/handlers/socket_handler.py b/astrbot/core/platform/sources/cli/handlers/socket_handler.py new file mode 100644 index 0000000000..9ebecf4af3 --- /dev/null +++ b/astrbot/core/platform/sources/cli/handlers/socket_handler.py @@ -0,0 +1,238 @@ +"""Socket客户端处理器 + +负责处理单个Socket客户端连接。 +""" + +import asyncio +import json +import uuid +from collections.abc import Callable +from typing import TYPE_CHECKING + +from astrbot import logger + +from ..interfaces import IHandler, IMessageConverter, ISessionManager, ITokenValidator +from ..message.response_builder import ResponseBuilder + +if TYPE_CHECKING: + from astrbot.core.platform.platform_metadata import PlatformMetadata + + from ..cli_event import CLIMessageEvent + + +class SocketClientHandler: + """Socket客户端处理器 + + 处理单个客户端连接，不实现IHandler（因为它不是独立运行的模式）。 + + I/O契约: + Input: socket连接 + Output: None (发送JSON响应到客户端) + """ + + RECV_BUFFER_SIZE = 4096 + MAX_REQUEST_SIZE = 1024 * 1024 # 1MB 最大请求大小 + RESPONSE_TIMEOUT = 30.0 + + def __init__( + self, + token_manager: ITokenValidator, + message_converter: IMessageConverter, + session_manager: ISessionManager, + platform_meta: "PlatformMetadata", + output_queue: asyncio.Queue, + event_committer: Callable[["CLIMessageEvent"], None], + use_isolated_sessions: bool = False, + ): + """初始化Socket客户端处理器""" + self.token_manager = token_manager + self.message_converter = message_converter + self.session_manager = session_manager + self.platform_meta = platform_meta + self.output_queue = output_queue + self.event_committer = event_committer + self.use_isolated_sessions = use_isolated_sessions + + async def handle(self, client_socket) -> None: + """处理单个客户端连接""" + try: + loop = asyncio.get_running_loop() + + # 接收请求（带大小限制） + data = await self._recv_with_limit(loop, client_socket) + if not data: + return + + # 解析并验证请求 + request = self._parse_request(data) + if request is None: + await self._send_response( + loop, + client_socket, + ResponseBuilder.build_error("Invalid JSON format"), + ) + return + + message_text = request.get("message", "") + request_id = request.get("request_id", str(uuid.uuid4())) + auth_token = request.get("auth_token", "") + + # Token验证 + if not self.token_manager.validate(auth_token): + error_msg = ( + "Unauthorized: missing token" + if not auth_token + else "Unauthorized: invalid token" + ) + await self._send_response( + loop, + client_socket, + ResponseBuilder.build_error(error_msg, request_id, "AUTH_FAILED"), + ) + return + + # 处理消息 + response = await self._process_message(message_text, request_id) + await self._send_response(loop, client_socket, response) + + except Exception as e: + logger.error("Socket handler error: %s", e, exc_info=True) + finally: + try: + client_socket.close() + except Exception as e: + logger.warning("Failed to close socket: %s", e) + + async def _recv_with_limit(self, loop, client_socket) -> bytes: + """接收数据，带大小限制防止DoS攻击""" + chunks = [] + total_size = 0 + + while True: + chunk = await loop.sock_recv(client_socket, self.RECV_BUFFER_SIZE) + if not chunk: + break + + total_size += len(chunk) + if total_size > self.MAX_REQUEST_SIZE: + logger.warning( + "Request too large: %d bytes, limit: %d", + total_size, + self.MAX_REQUEST_SIZE, + ) + return b"" + + chunks.append(chunk) + + # 检查是否接收完整（JSON以}结尾） + if chunk.rstrip().endswith(b"}"): + break + + return b"".join(chunks) + + def _parse_request(self, data: bytes) -> dict | None: + """解析JSON请求""" + try: + return json.loads(data.decode("utf-8")) + except json.JSONDecodeError: + return None + + async def _send_response(self, loop, client_socket, response: str) -> None: + """发送响应""" + await loop.sock_sendall(client_socket, response.encode("utf-8")) + + async def _process_message(self, message_text: str, request_id: str) -> str: + """处理消息并返回JSON响应""" + from ..cli_event import CLIMessageEvent + + response_future = asyncio.Future() + + message = self.message_converter.convert( + message_text, + request_id=request_id, + use_isolated_session=self.use_isolated_sessions, + ) + + self.session_manager.register(message.session_id) + + message_event = CLIMessageEvent( + message_str=message.message_str, + message_obj=message, + platform_meta=self.platform_meta, + session_id=message.session_id, + output_queue=self.output_queue, + response_future=response_future, + ) + + self.event_committer(message_event) + + try: + message_chain = await asyncio.wait_for( + response_future, timeout=self.RESPONSE_TIMEOUT + ) + return ResponseBuilder.build_success(message_chain, request_id) + except asyncio.TimeoutError: + # 超时时取消延迟响应任务，防止资源泄露 + if ( + hasattr(message_event, "_response_delay_task") + and message_event._response_delay_task + ): + message_event._response_delay_task.cancel() + return ResponseBuilder.build_error("Request timeout", request_id, "TIMEOUT") + + +class SocketModeHandler(IHandler): + """Socket模式处理器 + + 管理Socket服务器的生命周期，实现IHandler接口。 + """ + + def __init__( + self, + server, + client_handler: SocketClientHandler, + connection_info_writer: Callable[[dict, str], None], + data_path: str, + ): + """初始化Socket模式处理器 + + Args: + server: Socket服务器实例 + client_handler: 客户端处理器 + connection_info_writer: 连接信息写入函数 + data_path: 数据目录路径 + """ + self.server = server + self.client_handler = client_handler + self.connection_info_writer = connection_info_writer + self.data_path = data_path + self._running = False + + async def run(self) -> None: + """运行Socket服务器""" + self._running = True + + try: + await self.server.start() + logger.info("Socket server started: %s", type(self.server).__name__) + + # 写入连接信息 + connection_info = self.server.get_connection_info() + self.connection_info_writer(connection_info, self.data_path) + + # 接受连接循环 + while self._running: + try: + client_socket, _ = await self.server.accept_connection() + asyncio.create_task(self.client_handler.handle(client_socket)) + except Exception as e: + if self._running: + logger.error("Socket accept error: %s", e) + await asyncio.sleep(0.1) + + finally: + await self.server.stop() + + def stop(self) -> None: + """停止Socket服务器""" + self._running = False diff --git a/astrbot/core/platform/sources/cli/handlers/tty_handler.py b/astrbot/core/platform/sources/cli/handlers/tty_handler.py new file mode 100644 index 0000000000..6e15e1d8b3 --- /dev/null +++ b/astrbot/core/platform/sources/cli/handlers/tty_handler.py @@ -0,0 +1,125 @@ +"""TTY交互模式处理器 + +负责处理TTY交互模式的输入输出。 +""" + +import asyncio +from collections.abc import Callable +from typing import TYPE_CHECKING + +from astrbot import logger +from astrbot.core.message.message_event_result import MessageChain + +from ..interfaces import IHandler, IMessageConverter + +if TYPE_CHECKING: + from astrbot.core.platform.platform_metadata import PlatformMetadata + + from ..cli_event import CLIMessageEvent + + +class TTYHandler(IHandler): + """TTY交互模式处理器 + + 实现IHandler接口，提供命令行交互功能。 + + I/O契约: + Input: 用户键盘输入 + Output: None (打印到stdout) + """ + + EXIT_COMMANDS = frozenset({"exit", "quit"}) + BANNER = """ +============================================================ +AstrBot CLI Simulator +============================================================ +Type your message and press Enter to send. +Type 'exit' or 'quit' to stop. +============================================================ +""" + + def __init__( + self, + message_converter: IMessageConverter, + platform_meta: "PlatformMetadata", + output_queue: asyncio.Queue, + event_committer: Callable[["CLIMessageEvent"], None], + ): + """初始化TTY处理器""" + self.message_converter = message_converter + self.platform_meta = platform_meta + self.output_queue = output_queue + self.event_committer = event_committer + self._running = False + + async def run(self) -> None: + """运行TTY交互模式""" + self._running = True + print(self.BANNER) + + output_task = asyncio.create_task(self._output_loop()) + + try: + await self._input_loop() + except KeyboardInterrupt: + logger.info("Received KeyboardInterrupt") + finally: + self._running = False + output_task.cancel() + try: + await output_task + except asyncio.CancelledError: + pass + + def stop(self) -> None: + """停止TTY模式""" + self._running = False + + async def _input_loop(self) -> None: + """输入循环""" + loop = asyncio.get_running_loop() + + while self._running: + user_input = await loop.run_in_executor(None, input, "You: ") + user_input = user_input.strip() + + if not user_input: + continue + + if user_input.lower() in self.EXIT_COMMANDS: + break + + await self._handle_input(user_input) + + async def _handle_input(self, text: str) -> None: + """处理用户输入""" + from ..cli_event import CLIMessageEvent + + message = self.message_converter.convert(text) + + message_event = CLIMessageEvent( + message_str=message.message_str, + message_obj=message, + platform_meta=self.platform_meta, + session_id=message.session_id, + output_queue=self.output_queue, + ) + + self.event_committer(message_event) + + async def _output_loop(self) -> None: + """输出循环""" + while self._running: + try: + message_chain = await asyncio.wait_for( + self.output_queue.get(), timeout=0.5 + ) + self._print_response(message_chain) + except asyncio.TimeoutError: + continue + except asyncio.CancelledError: + break + + def _print_response(self, message_chain: MessageChain) -> None: + """打印响应""" + print(f"\nBot: {message_chain.get_plain_text()}\n") diff --git a/astrbot/core/platform/sources/cli/interfaces.py b/astrbot/core/platform/sources/cli/interfaces.py new file mode 100644 index 0000000000..8ef2a9a959 --- /dev/null +++ b/astrbot/core/platform/sources/cli/interfaces.py @@ -0,0 +1,91 @@ +"""CLI核心接口定义 + +定义CLI模块的核心抽象接口，遵循依赖倒置原则。 +所有具体实现依赖于这些接口，而非具体实现。 +""" + +from abc import ABC, abstractmethod +from typing import Any, Protocol, runtime_checkable + +from astrbot.core.message.message_event_result import MessageChain + + +@runtime_checkable +class ITokenValidator(Protocol): + """Token验证器接口""" + + def validate(self, token: str) -> bool: + """验证Token""" + ... + + +@runtime_checkable +class IMessageConverter(Protocol): + """消息转换器接口""" + + def convert( + self, + text: str, + request_id: str | None = None, + use_isolated_session: bool = False, + ) -> Any: + """将文本转换为消息对象""" + ... + + +@runtime_checkable +class ISessionManager(Protocol): + """会话管理器接口""" + + def register(self, session_id: str) -> None: + """注册会话""" + ... + + def touch(self, session_id: str) -> None: + """更新会话时间戳""" + ... + + def is_expired(self, session_id: str) -> bool: + """检查会话是否过期""" + ... + + +class IHandler(ABC): + """处理器抽象基类 + + 所有模式处理器（Socket/TTY/File）的共同接口。 + """ + + @abstractmethod + async def run(self) -> None: + """运行处理器""" + pass + + @abstractmethod + def stop(self) -> None: + """停止处理器""" + pass + + +class IResponseBuilder(Protocol): + """响应构建器接口""" + + def build_success(self, message_chain: MessageChain, request_id: str) -> str: + """构建成功响应""" + ... + + def build_error(self, error_msg: str, request_id: str | None = None) -> str: + """构建错误响应""" + ... + + +class IImageProcessor(Protocol): + """图片处理器接口""" + + def preprocess_chain(self, message_chain: MessageChain) -> None: + """预处理消息链中的图片""" + ... + + def extract_images(self, message_chain: MessageChain) -> list[Any]: + """从消息链中提取图片信息""" + ... diff --git a/astrbot/core/platform/sources/cli/message/__init__.py b/astrbot/core/platform/sources/cli/message/__init__.py new file mode 100644 index 0000000000..42e4671761 --- /dev/null +++ b/astrbot/core/platform/sources/cli/message/__init__.py @@ -0,0 +1,14 @@ +"""CLI消息处理模块""" + +from .converter import MessageConverter +from .image_processor import ImageInfo, ImageProcessor +from .response_builder import ResponseBuilder +from .response_collector import ResponseCollector + +__all__ = [ + "MessageConverter", + "ImageProcessor", + "ImageInfo", + "ResponseCollector", + "ResponseBuilder", +] diff --git a/astrbot/core/platform/sources/cli/message/converter.py b/astrbot/core/platform/sources/cli/message/converter.py new file mode 100644 index 0000000000..7cf7a296fe --- /dev/null +++ b/astrbot/core/platform/sources/cli/message/converter.py @@ -0,0 +1,74 @@ +"""消息转换器 + +负责将文本输入转换为AstrBotMessage对象。 +""" + +import uuid + +from astrbot import logger +from astrbot.core.message.components import Plain +from astrbot.core.platform import AstrBotMessage, MessageMember, MessageType + + +class MessageConverter: + """消息转换器 + + I/O契约: + Input: text (str), request_id (str | None) + Output: AstrBotMessage + """ + + def __init__( + self, + default_session_id: str = "cli_session", + user_id: str = "cli_user", + user_nickname: str = "CLI User", + ): + """初始化消息转换器 + + Args: + default_session_id: 默认会话ID + user_id: 用户ID + user_nickname: 用户昵称 + """ + self.default_session_id = default_session_id + self.user_id = user_id + self.user_nickname = user_nickname + + def convert( + self, + text: str, + request_id: str | None = None, + use_isolated_session: bool = False, + ) -> AstrBotMessage: + """将文本转换为AstrBotMessage + + Args: + text: 原始文本 + request_id: 请求ID（用于会话隔离） + use_isolated_session: 是否使用隔离会话 + + Returns: + AstrBotMessage对象 + """ + logger.debug("Converting input: text=%s, request_id=%s", text, request_id) + + message = AstrBotMessage() + message.self_id = "cli_bot" + message.message_str = text + message.message = [Plain(text)] + message.type = MessageType.FRIEND_MESSAGE + message.message_id = str(uuid.uuid4()) + + # 根据配置决定会话ID + if use_isolated_session and request_id: + message.session_id = f"cli_session_{request_id}" + else: + message.session_id = self.default_session_id + + message.sender = MessageMember( + user_id=self.user_id, + nickname=self.user_nickname, + ) + + return message diff --git a/astrbot/core/platform/sources/cli/message/image_processor.py b/astrbot/core/platform/sources/cli/message/image_processor.py new file mode 100644 index 0000000000..1b6f28f935 --- /dev/null +++ b/astrbot/core/platform/sources/cli/message/image_processor.py @@ -0,0 +1,247 @@ +"""图片处理模块 + +拆分为单一职责的小组件： +- ImageCodec: base64编解码 +- ImageFileIO: 文件读写 +- ImageExtractor: 从消息链提取图片 +- ImageInfo: 数据结构 +""" + +import base64 +import os +import tempfile +from dataclasses import dataclass + +from astrbot import logger +from astrbot.core.message.components import Image +from astrbot.core.message.message_event_result import MessageChain +from astrbot.core.utils.astrbot_path import get_astrbot_temp_path + +# ============================================================ +# 数据结构 +# ============================================================ + + +@dataclass +class ImageInfo: + """图片信息数据结构""" + + type: str # "url", "file", "base64" + url: str | None = None + path: str | None = None + base64_data: str | None = None + size: int | None = None + error: str | None = None + + def to_dict(self) -> dict: + """转换为字典""" + result = {"type": self.type} + if self.url: + result["url"] = self.url + if self.path: + result["path"] = self.path + if self.base64_data: + result["base64_data"] = self.base64_data + if self.size: + result["size"] = self.size + if self.error: + result["error"] = self.error + return result + + +# ============================================================ +# 原子组件：Base64编解码 +# ============================================================ + + +class ImageCodec: + """Base64编解码器 + + 单一职责：仅负责base64编解码 + """ + + @staticmethod + def encode(data: bytes) -> str: + """编码为base64""" + return base64.b64encode(data).decode("utf-8") + + @staticmethod + def decode(base64_str: str) -> bytes: + """解码base64""" + return base64.b64decode(base64_str) + + +# ============================================================ +# 原子组件：文件I/O +# ============================================================ + + +class ImageFileIO: + """图片文件I/O + + 单一职责：仅负责文件读写 + """ + + @staticmethod + def read(file_path: str) -> bytes | None: + """读取文件""" + try: + if os.path.exists(file_path): + with open(file_path, "rb") as f: + return f.read() + except Exception as e: + logger.error("Failed to read file %s: %s", file_path, e) + return None + + @staticmethod + def write_temp(data: bytes, suffix: str = ".png") -> str | None: + """写入临时文件""" + try: + temp_dir = get_astrbot_temp_path() + os.makedirs(temp_dir, exist_ok=True) + + temp_file = tempfile.NamedTemporaryFile( + delete=False, + suffix=suffix, + dir=temp_dir, + ) + temp_file.write(data) + temp_file.close() + return temp_file.name + except Exception as e: + logger.error("Failed to write temp file: %s", e) + return None + + +# ============================================================ +# 组合组件：图片提取器 +# ============================================================ + + +class ImageExtractor: + """图片提取器 + + 组合ImageCodec和ImageFileIO，从消息链提取图片信息 + """ + + @staticmethod + def extract(message_chain: MessageChain) -> list[ImageInfo]: + """从消息链提取图片信息""" + images = [] + + for comp in message_chain.chain: + if isinstance(comp, Image) and comp.file: + image_info = ImageExtractor._process_image(comp.file) + images.append(image_info) + + return images + + @staticmethod + def _process_image(file_ref: str) -> ImageInfo: + """处理单个图片引用""" + if file_ref.startswith("http"): + return ImageInfo(type="url", url=file_ref) + + elif file_ref.startswith("file:///"): + return ImageExtractor._process_local_file(file_ref[8:]) + + elif file_ref.startswith("base64://"): + return ImageExtractor._process_base64(file_ref[9:]) + + return ImageInfo(type="unknown") + + @staticmethod + def _process_local_file(file_path: str) -> ImageInfo: + """处理本地文件""" + info = ImageInfo(type="file", path=file_path) + + data = ImageFileIO.read(file_path) + if data: + info.base64_data = ImageCodec.encode(data) + info.size = len(data) + else: + info.error = "Failed to read file" + + return info + + @staticmethod + def _process_base64(base64_data: str) -> ImageInfo: + """处理base64数据""" + try: + data = ImageCodec.decode(base64_data) + temp_path = ImageFileIO.write_temp(data) + + if temp_path: + return ImageInfo(type="file", path=temp_path, size=len(data)) + else: + return ImageInfo(type="base64", error="Failed to save to temp file") + except Exception as e: + return ImageInfo(type="base64", error=str(e)) + + +# ============================================================ +# 组合组件：消息链预处理器 +# ============================================================ + + +class ChainPreprocessor: + """消息链预处理器 + + 将消息链中的本地文件图片转换为base64 + """ + + @staticmethod + def preprocess(message_chain: MessageChain) -> None: + """预处理消息链（原地修改）""" + for comp in message_chain.chain: + if ( + isinstance(comp, Image) + and comp.file + and comp.file.startswith("file:///") + ): + file_path = comp.file[8:] + data = ImageFileIO.read(file_path) + if data: + comp.file = f"base64://{ImageCodec.encode(data)}" + + +# ============================================================ +# 向后兼容：ImageProcessor门面 +# ============================================================ + + +class ImageProcessor: + """图片处理器门面（向后兼容） + + 组合所有小组件，提供统一接口 + """ + + @staticmethod + def local_file_to_base64(file_path: str) -> str | None: + """将本地文件转换为base64""" + data = ImageFileIO.read(file_path) + return ImageCodec.encode(data) if data else None + + @staticmethod + def base64_to_temp_file(base64_data: str) -> str | None: + """将base64保存到临时文件""" + try: + data = ImageCodec.decode(base64_data) + return ImageFileIO.write_temp(data) + except Exception: + return None + + @staticmethod + def preprocess_chain(message_chain: MessageChain) -> None: + """预处理消息链""" + ChainPreprocessor.preprocess(message_chain) + + @staticmethod + def extract_images(message_chain: MessageChain) -> list[ImageInfo]: + """提取图片信息""" + return ImageExtractor.extract(message_chain) + + @staticmethod + def image_info_to_dict(image_info: ImageInfo) -> dict: + """转换为字典""" + return image_info.to_dict() diff --git a/astrbot/core/platform/sources/cli/message/response_builder.py b/astrbot/core/platform/sources/cli/message/response_builder.py new file mode 100644 index 0000000000..b07a8c49dd --- /dev/null +++ b/astrbot/core/platform/sources/cli/message/response_builder.py @@ -0,0 +1,84 @@ +"""JSON响应构建器 + +负责构建统一格式的JSON响应，与业务逻辑解耦。 +""" + +import json +from typing import Any + +from astrbot.core.message.message_event_result import MessageChain + +from .image_processor import ImageInfo, ImageProcessor + + +class ResponseBuilder: + """JSON响应构建器 + + I/O契约: + Input: MessageChain 或 error_msg + Output: JSON字符串 + """ + + @staticmethod + def build_success( + message_chain: MessageChain, + request_id: str, + extra: dict[str, Any] | None = None, + ) -> str: + """构建成功响应 + + Args: + message_chain: 消息链 + request_id: 请求ID + extra: 额外字段 + + Returns: + JSON字符串 + """ + response_text = message_chain.get_plain_text() + images = ImageProcessor.extract_images(message_chain) + + result = { + "status": "success", + "response": response_text, + "images": [ResponseBuilder._image_to_dict(img) for img in images], + "request_id": request_id, + } + + if extra: + result.update(extra) + + return json.dumps(result, ensure_ascii=False) + + @staticmethod + def build_error( + error_msg: str, + request_id: str | None = None, + error_code: str | None = None, + ) -> str: + """构建错误响应 + + Args: + error_msg: 错误消息 + request_id: 请求ID + error_code: 错误代码 + + Returns: + JSON字符串 + """ + result = { + "status": "error", + "error": error_msg, + } + + if request_id: + result["request_id"] = request_id + if error_code: + result["error_code"] = error_code + + return json.dumps(result, ensure_ascii=False) + + @staticmethod + def _image_to_dict(image_info: ImageInfo) -> dict: + """将ImageInfo转换为字典""" + return ImageProcessor.image_info_to_dict(image_info) diff --git a/astrbot/core/platform/sources/cli/message/response_collector.py b/astrbot/core/platform/sources/cli/message/response_collector.py new file mode 100644 index 0000000000..65a09bd30f --- /dev/null +++ b/astrbot/core/platform/sources/cli/message/response_collector.py @@ -0,0 +1,104 @@ +"""响应收集器 + +负责收集多次回复并延迟返回，支持工具调用等多轮场景。 +""" + +import asyncio + +from astrbot import logger +from astrbot.core.message.message_event_result import MessageChain + +from .image_processor import ImageProcessor + + +class ResponseCollector: + """响应收集器 + + I/O契约: + Input: MessageChain (多次) + Output: MessageChain (合并后) + """ + + # 延迟配置 + INITIAL_DELAY = 5.0 # 首次回复延迟 + EXTENDED_DELAY = 10.0 # 后续回复延迟 + + def __init__(self, response_future: asyncio.Future): + """初始化响应收集器 + + Args: + response_future: 响应Future对象 + """ + self.response_future = response_future + self.buffer: MessageChain | None = None + self._delay_task: asyncio.Task | None = None + self._current_delay = self.INITIAL_DELAY + + def collect(self, message_chain: MessageChain) -> None: + """收集消息到缓冲区 + + Args: + message_chain: 消息链 + """ + if self.response_future.done(): + logger.warning("Response future already done, skipping collect") + return + + # 预处理图片 + ImageProcessor.preprocess_chain(message_chain) + + if not self.buffer: + # 首次收集 + self.buffer = message_chain + self._current_delay = self.INITIAL_DELAY + logger.info( + "First collect: initialized buffer with %.1fs delay", + self._current_delay, + ) + else: + # 追加到缓冲区 + self.buffer.chain.extend(message_chain.chain) + self._current_delay = self.EXTENDED_DELAY + logger.info( + "Appended to buffer (switched to %.1fs delay), total: %d components", + self._current_delay, + len(self.buffer.chain), + ) + + # 重置延迟任务 + self._reset_delay_task() + + def _reset_delay_task(self) -> None: + """重置延迟任务""" + # 取消之前的延迟任务 + if self._delay_task and not self._delay_task.done(): + self._delay_task.cancel() + logger.debug("Cancelled previous delay task") + + # 启动新的延迟任务 + self._delay_task = asyncio.create_task(self._delayed_response()) + logger.debug("Started new delay task (%.1fs)", self._current_delay) + + async def _delayed_response(self) -> None: + """延迟响应：等待一段时间后统一返回""" + try: + await asyncio.sleep(self._current_delay) + + if self.response_future and not self.response_future.done(): + self.response_future.set_result(self.buffer) + logger.debug( + "Set delayed response with %d components", + len(self.buffer.chain) if self.buffer else 0, + ) + else: + logger.warning( + "Response future already done or None, skipping set_result" + ) + + except asyncio.CancelledError: + # 被取消是正常的（有新消息到来） + pass + except Exception as e: + logger.error("Failed to set delayed response: %s", e) + if self.response_future and not self.response_future.done(): + self.response_future.set_exception(e) diff --git a/astrbot/core/platform/sources/cli/platform_detector.py b/astrbot/core/platform/sources/cli/platform_detector.py index de07dd7546..a6bf09d16d 100644 --- a/astrbot/core/platform/sources/cli/platform_detector.py +++ b/astrbot/core/platform/sources/cli/platform_detector.py @@ -104,12 +104,16 @@ def _check_windows_unix_socket_support(python_version: tuple[int, int, int]) -> - Python 3.9+ - Windows 10 build 17063+ + Uses actual socket creation test as primary method (most reliable). + Args: python_version: Python version tuple Returns: True if Unix Socket is supported, False otherwise """ + import socket + start_time = time.time() logger.debug( f"[ENTRY] _check_windows_unix_socket_support inputs={{python_version={python_version}}}" @@ -126,55 +130,43 @@ def _check_windows_unix_socket_support(python_version: tuple[int, int, int]) -> ) return False - # Check Windows build version + # 方法1：实际尝试创建 Unix Socket（最可靠） try: - win_ver = platform.win32_ver() - logger.debug(f"[PROCESS] platform.win32_ver() returned: {win_ver}") - - # win_ver returns: (release, version, csd, ptype) - # version format: "10.0.19041" - version_str = win_ver[1] - - if not version_str: - logger.warning("[PROCESS] Unable to determine Windows build version") + if hasattr(socket, "AF_UNIX"): + test_sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM) + test_sock.close() + logger.debug("[PROCESS] Unix Socket creation test passed") duration_ms = (time.time() - start_time) * 1000 logger.debug( - f"[EXIT] _check_windows_unix_socket_support return=False time_ms={duration_ms:.2f}" - ) - return False - - # Parse build number from version string - # Format: "major.minor.build" - parts = version_str.split(".") - if len(parts) >= 3: - build = int(parts[2]) - logger.debug(f"[PROCESS] Windows build number: {build}") - - # Unix Socket support requires build 17063+ - if build >= 17063: - logger.debug(f"[PROCESS] Build {build} >= 17063, Unix Socket supported") - supports = True - else: - logger.debug( - f"[PROCESS] Build {build} < 17063, Unix Socket not supported" - ) - supports = False - else: - logger.warning( - f"[PROCESS] Unable to parse build number from version: {version_str}" + f"[EXIT] _check_windows_unix_socket_support return=True time_ms={duration_ms:.2f}" ) - supports = False + return True + except (OSError, AttributeError) as e: + logger.debug(f"[PROCESS] Unix Socket creation test failed: {e}") + # 方法2：检查 Windows 版本号（备选，仅用于日志） + try: + win_ver = platform.win32_ver() + logger.debug(f"[PROCESS] platform.win32_ver() returned: {win_ver}") + + version_str = win_ver[1] + if version_str: + parts = version_str.split(".") + if len(parts) >= 3: + build = int(parts[2]) + logger.debug(f"[PROCESS] Windows build number: {build}") + if build >= 17063: + logger.debug( + f"[PROCESS] Build {build} >= 17063, but socket test failed" + ) except Exception as e: - logger.error(f"[ERROR] Failed to check Windows version: {e}", exc_info=True) - supports = False + logger.debug(f"[PROCESS] Failed to check Windows version: {e}") duration_ms = (time.time() - start_time) * 1000 logger.debug( - f"[EXIT] _check_windows_unix_socket_support return={supports} time_ms={duration_ms:.2f}" + f"[EXIT] _check_windows_unix_socket_support return=False time_ms={duration_ms:.2f}" ) - - return supports + return False def _check_unix_socket_support( diff --git a/astrbot/core/platform/sources/cli/session/__init__.py b/astrbot/core/platform/sources/cli/session/__init__.py new file mode 100644 index 0000000000..44056af123 --- /dev/null +++ b/astrbot/core/platform/sources/cli/session/__init__.py @@ -0,0 +1,5 @@ +"""CLI会话管理模块""" + +from .session_manager import SessionManager + +__all__ = ["SessionManager"] diff --git a/astrbot/core/platform/sources/cli/session/session_manager.py b/astrbot/core/platform/sources/cli/session/session_manager.py new file mode 100644 index 0000000000..d5b00e5a0d --- /dev/null +++ b/astrbot/core/platform/sources/cli/session/session_manager.py @@ -0,0 +1,123 @@ +"""会话管理器 + +负责会话的创建、跟踪和过期清理。 +""" + +import asyncio +import time + +from astrbot import logger + + +class SessionManager: + """会话管理器 + + I/O契约: + Input: session_id (str), ttl (int) + Output: None (管理会话生命周期) + """ + + CLEANUP_INTERVAL = 10 # 清理检查间隔（秒） + + def __init__(self, ttl: int = 30, enabled: bool = False): + """初始化会话管理器 + + Args: + ttl: 会话过期时间（秒） + enabled: 是否启用会话隔离 + """ + self.ttl = ttl + self.enabled = enabled + self._timestamps: dict[str, float] = {} + self._cleanup_task: asyncio.Task | None = None + self._running = False + + def register(self, session_id: str) -> None: + """注册新会话 + + Args: + session_id: 会话ID + """ + if not self.enabled: + return + + if session_id not in self._timestamps: + self._timestamps[session_id] = time.time() + logger.debug("Created isolated session: %s, TTL=%ds", session_id, self.ttl) + + def touch(self, session_id: str) -> None: + """更新会话时间戳 + + Args: + session_id: 会话ID + """ + if self.enabled and session_id in self._timestamps: + self._timestamps[session_id] = time.time() + + def is_expired(self, session_id: str) -> bool: + """检查会话是否过期 + + Args: + session_id: 会话ID + + Returns: + 是否过期 + """ + if not self.enabled: + return False + + timestamp = self._timestamps.get(session_id) + if timestamp is None: + return True + + return time.time() - timestamp > self.ttl + + def start_cleanup_task(self) -> None: + """启动清理任务""" + if not self.enabled: + return + + self._running = True + self._cleanup_task = asyncio.create_task(self._cleanup_loop()) + logger.info("Session cleanup task started, TTL=%ds", self.ttl) + + async def stop_cleanup_task(self) -> None: + """停止清理任务""" + self._running = False + + if self._cleanup_task and not self._cleanup_task.done(): + self._cleanup_task.cancel() + try: + await self._cleanup_task + except asyncio.CancelledError: + logger.debug("Cleanup task cancelled") + + async def _cleanup_loop(self) -> None: + """清理循环""" + while self._running: + try: + await asyncio.sleep(self.CLEANUP_INTERVAL) + + if not self.enabled: + continue + + current_time = time.time() + expired_sessions = [ + sid + for sid, ts in list(self._timestamps.items()) + if current_time - ts > self.ttl + ] + + for session_id in expired_sessions: + logger.info("Cleaning expired session: %s", session_id) + self._timestamps.pop(session_id, None) + + if expired_sessions: + logger.info("Cleaned %d expired sessions", len(expired_sessions)) + + except asyncio.CancelledError: + break + except Exception as e: + logger.error("Session cleanup error: %s", e) + + logger.info("Session cleanup task stopped") diff --git a/astrbot/core/platform/sources/cli/utils/__init__.py b/astrbot/core/platform/sources/cli/utils/__init__.py new file mode 100644 index 0000000000..f364a5fcc0 --- /dev/null +++ b/astrbot/core/platform/sources/cli/utils/__init__.py @@ -0,0 +1,56 @@ +"""CLI工具模块 - AOP装饰器集合 + +提供横切关注点的装饰器： +- 异常处理: handle_exceptions, CLIError, AuthenticationError, ValidationError, TimeoutError +- 重试机制: retry +- 超时控制: timeout +- 日志记录: log_entry_exit, log_performance, log_request +- 权限校验: require_auth, require_whitelist +- 组合装饰器: with_logging_and_error_handling +""" + +from .decorators import ( + AuthenticationError, + # 异常类 + CLIError, + TimeoutError, + ValidationError, + # 异常处理 + handle_exceptions, + # 日志 + log_entry_exit, + log_performance, + log_request, + # 权限 + require_auth, + require_whitelist, + # 重试 + retry, + # 超时 + timeout, + # 组合 + with_logging_and_error_handling, +) + +__all__ = [ + # 异常类 + "CLIError", + "AuthenticationError", + "ValidationError", + "TimeoutError", + # 异常处理 + "handle_exceptions", + # 重试 + "retry", + # 超时 + "timeout", + # 日志 + "log_entry_exit", + "log_performance", + "log_request", + # 权限 + "require_auth", + "require_whitelist", + # 组合 + "with_logging_and_error_handling", +] diff --git a/astrbot/core/platform/sources/cli/utils/decorators.py b/astrbot/core/platform/sources/cli/utils/decorators.py new file mode 100644 index 0000000000..ed2448ac58 --- /dev/null +++ b/astrbot/core/platform/sources/cli/utils/decorators.py @@ -0,0 +1,496 @@ +"""AOP装饰器集合 + +将横切关注点（日志、异常处理、权限校验、重试）从业务代码中抽离。 +遵循单一职责原则，每个装饰器只处理一个关注点。 +""" + +import asyncio +import functools +import time +from collections.abc import Callable +from typing import TypeVar + +from astrbot import logger + +F = TypeVar("F", bound=Callable) + + +# ============================================================ +# 异常处理装饰器 +# ============================================================ + + +class CLIError(Exception): + """CLI模块基础异常""" + + def __init__(self, message: str, error_code: str = "CLI_ERROR"): + super().__init__(message) + self.error_code = error_code + + +class AuthenticationError(CLIError): + """认证失败异常""" + + def __init__(self, message: str = "Authentication failed"): + super().__init__(message, "AUTH_FAILED") + + +class ValidationError(CLIError): + """验证失败异常""" + + def __init__(self, message: str = "Validation failed"): + super().__init__(message, "VALIDATION_ERROR") + + +class TimeoutError(CLIError): + """超时异常""" + + def __init__(self, message: str = "Operation timed out"): + super().__init__(message, "TIMEOUT") + + +def handle_exceptions( + *exception_types: type[Exception], + default_return=None, + reraise: bool = False, + log_level: str = "error", +): + """统一异常处理装饰器 + + Args: + exception_types: 要捕获的异常类型，默认捕获所有Exception + default_return: 异常时的默认返回值 + reraise: 是否重新抛出异常 + log_level: 日志级别 (debug/info/warning/error) + """ + if not exception_types: + exception_types = (Exception,) + + def decorator(func: F) -> F: + @functools.wraps(func) + async def async_wrapper(*args, **kwargs): + try: + return await func(*args, **kwargs) + except exception_types as e: + _log_exception(func.__qualname__, e, log_level) + if reraise: + raise + return default_return + + @functools.wraps(func) + def sync_wrapper(*args, **kwargs): + try: + return func(*args, **kwargs) + except exception_types as e: + _log_exception(func.__qualname__, e, log_level) + if reraise: + raise + return default_return + + if asyncio.iscoroutinefunction(func): + return async_wrapper + return sync_wrapper + + return decorator + + +def _log_exception(func_name: str, exc: Exception, level: str) -> None: + """记录异常日志""" + log_func = getattr(logger, level, logger.error) + error_code = getattr(exc, "error_code", "UNKNOWN") + log_func("[EXCEPTION] %s: %s (code=%s)", func_name, exc, error_code) + + +# ============================================================ +# 重试装饰器 +# ============================================================ + + +def retry( + max_attempts: int = 3, + delay: float = 1.0, + backoff: float = 2.0, + exceptions: tuple = (Exception,), +): + """重试装饰器 + + Args: + max_attempts: 最大重试次数 + delay: 初始延迟（秒） + backoff: 延迟倍增因子 + exceptions: 触发重试的异常类型 + """ + + def decorator(func: F) -> F: + @functools.wraps(func) + async def async_wrapper(*args, **kwargs): + current_delay = delay + last_exception = None + + for attempt in range(max_attempts): + try: + return await func(*args, **kwargs) + except exceptions as e: + last_exception = e + if attempt < max_attempts - 1: + logger.warning( + "[RETRY] %s attempt %d/%d failed: %s, retrying in %.1fs", + func.__qualname__, + attempt + 1, + max_attempts, + e, + current_delay, + ) + await asyncio.sleep(current_delay) + current_delay *= backoff + else: + logger.error( + "[RETRY] %s all %d attempts failed", + func.__qualname__, + max_attempts, + ) + + raise last_exception + + @functools.wraps(func) + def sync_wrapper(*args, **kwargs): + current_delay = delay + last_exception = None + + for attempt in range(max_attempts): + try: + return func(*args, **kwargs) + except exceptions as e: + last_exception = e + if attempt < max_attempts - 1: + logger.warning( + "[RETRY] %s attempt %d/%d failed: %s, retrying in %.1fs", + func.__qualname__, + attempt + 1, + max_attempts, + e, + current_delay, + ) + time.sleep(current_delay) + current_delay *= backoff + else: + logger.error( + "[RETRY] %s all %d attempts failed", + func.__qualname__, + max_attempts, + ) + + raise last_exception + + if asyncio.iscoroutinefunction(func): + return async_wrapper + return sync_wrapper + + return decorator + + +# ============================================================ +# 超时装饰器 +# ============================================================ + + +def timeout(seconds: float): + """超时装饰器 + + Args: + seconds: 超时时间（秒） + """ + + def decorator(func: F) -> F: + @functools.wraps(func) + async def async_wrapper(*args, **kwargs): + try: + return await asyncio.wait_for( + func(*args, **kwargs), + timeout=seconds, + ) + except asyncio.TimeoutError: + logger.error( + "[TIMEOUT] %s exceeded %.1fs", + func.__qualname__, + seconds, + ) + raise TimeoutError(f"{func.__qualname__} timed out after {seconds}s") + + if not asyncio.iscoroutinefunction(func): + raise TypeError("timeout decorator only supports async functions") + + return async_wrapper + + return decorator + + +# ============================================================ +# 日志装饰器 +# ============================================================ + + +def log_entry_exit(func: F) -> F: + """记录函数入口和出口的装饰器 + + 用于异步函数，记录调用开始和结束。 + """ + + @functools.wraps(func) + async def async_wrapper(*args, **kwargs): + func_name = func.__qualname__ + logger.debug("[ENTRY] %s", func_name) + try: + result = await func(*args, **kwargs) + logger.debug("[EXIT] %s", func_name) + return result + except Exception as e: + logger.error("[ERROR] %s: %s", func_name, e) + raise + + @functools.wraps(func) + def sync_wrapper(*args, **kwargs): + func_name = func.__qualname__ + logger.debug("[ENTRY] %s", func_name) + try: + result = func(*args, **kwargs) + logger.debug("[EXIT] %s", func_name) + return result + except Exception as e: + logger.error("[ERROR] %s: %s", func_name, e) + raise + + import asyncio + + if asyncio.iscoroutinefunction(func): + return async_wrapper + return sync_wrapper + + +def log_performance(threshold_ms: float = 100.0): + """记录性能的装饰器 + + 当执行时间超过阈值时记录警告。 + + Args: + threshold_ms: 阈值（毫秒） + """ + + def decorator(func: F) -> F: + @functools.wraps(func) + async def async_wrapper(*args, **kwargs): + start = time.perf_counter() + try: + return await func(*args, **kwargs) + finally: + elapsed_ms = (time.perf_counter() - start) * 1000 + if elapsed_ms > threshold_ms: + logger.warning( + "[PERF] %s took %.2fms (threshold: %.2fms)", + func.__qualname__, + elapsed_ms, + threshold_ms, + ) + + @functools.wraps(func) + def sync_wrapper(*args, **kwargs): + start = time.perf_counter() + try: + return func(*args, **kwargs) + finally: + elapsed_ms = (time.perf_counter() - start) * 1000 + if elapsed_ms > threshold_ms: + logger.warning( + "[PERF] %s took %.2fms (threshold: %.2fms)", + func.__qualname__, + elapsed_ms, + threshold_ms, + ) + + import asyncio + + if asyncio.iscoroutinefunction(func): + return async_wrapper + return sync_wrapper + + return decorator + + +def log_request(func: F) -> F: + """记录请求处理的装饰器 + + 专门用于请求处理函数，记录请求ID和处理结果。 + """ + + @functools.wraps(func) + async def wrapper(*args, **kwargs): + request_id = kwargs.get("request_id", "unknown") + func_name = func.__qualname__ + + logger.info("[REQUEST] %s started, request_id=%s", func_name, request_id) + start = time.perf_counter() + + try: + result = await func(*args, **kwargs) + elapsed_ms = (time.perf_counter() - start) * 1000 + logger.info( + "[REQUEST] %s completed, request_id=%s, elapsed=%.2fms", + func_name, + request_id, + elapsed_ms, + ) + return result + except Exception as e: + elapsed_ms = (time.perf_counter() - start) * 1000 + logger.error( + "[REQUEST] %s failed, request_id=%s, elapsed=%.2fms, error=%s", + func_name, + request_id, + elapsed_ms, + e, + ) + raise + + return wrapper + + +# ============================================================ +# 权限校验装饰器 +# ============================================================ + + +def require_auth(token_getter: Callable[[], str | None] = None): + """权限校验装饰器 + + Args: + token_getter: 获取有效token的函数，返回None表示禁用验证 + """ + + def decorator(func: F) -> F: + @functools.wraps(func) + async def async_wrapper(*args, **kwargs): + # 从kwargs获取提供的token + provided_token = kwargs.get("auth_token", "") + + # 获取有效token + valid_token = token_getter() if token_getter else None + + # 如果没有配置token，跳过验证 + if valid_token is None: + return await func(*args, **kwargs) + + # 验证token + if not provided_token: + logger.warning("[AUTH] Missing auth_token") + raise AuthenticationError("Missing authentication token") + + if provided_token != valid_token: + logger.warning( + "[AUTH] Invalid auth_token (length=%d)", len(provided_token) + ) + raise AuthenticationError("Invalid authentication token") + + return await func(*args, **kwargs) + + @functools.wraps(func) + def sync_wrapper(*args, **kwargs): + provided_token = kwargs.get("auth_token", "") + valid_token = token_getter() if token_getter else None + + if valid_token is None: + return func(*args, **kwargs) + + if not provided_token: + logger.warning("[AUTH] Missing auth_token") + raise AuthenticationError("Missing authentication token") + + if provided_token != valid_token: + logger.warning( + "[AUTH] Invalid auth_token (length=%d)", len(provided_token) + ) + raise AuthenticationError("Invalid authentication token") + + return func(*args, **kwargs) + + if asyncio.iscoroutinefunction(func): + return async_wrapper + return sync_wrapper + + return decorator + + +def require_whitelist( + whitelist: list[str] = None, id_getter: Callable[[tuple, dict], str] = None +): + """白名单校验装饰器 + + Args: + whitelist: 允许的ID列表，空列表表示允许所有 + id_getter: 从参数中获取ID的函数 + """ + + def decorator(func: F) -> F: + @functools.wraps(func) + async def async_wrapper(*args, **kwargs): + if whitelist and id_getter: + request_id = id_getter(args, kwargs) + if request_id not in whitelist: + logger.warning("[WHITELIST] Rejected request from: %s", request_id) + raise AuthenticationError(f"ID {request_id} not in whitelist") + return await func(*args, **kwargs) + + @functools.wraps(func) + def sync_wrapper(*args, **kwargs): + if whitelist and id_getter: + request_id = id_getter(args, kwargs) + if request_id not in whitelist: + logger.warning("[WHITELIST] Rejected request from: %s", request_id) + raise AuthenticationError(f"ID {request_id} not in whitelist") + return func(*args, **kwargs) + + if asyncio.iscoroutinefunction(func): + return async_wrapper + return sync_wrapper + + return decorator + + +# ============================================================ +# 组合装饰器 +# ============================================================ + + +def with_logging_and_error_handling( + log_entry: bool = True, + log_perf: bool = False, + perf_threshold_ms: float = 100.0, + handle_errors: bool = True, + default_return=None, +): + """组合装饰器：日志 + 异常处理 + + 简化常见的装饰器组合使用。 + + Args: + log_entry: 是否记录入口/出口 + log_perf: 是否记录性能 + perf_threshold_ms: 性能阈值 + handle_errors: 是否处理异常 + default_return: 异常时的默认返回值 + """ + + def decorator(func: F) -> F: + decorated = func + + if handle_errors: + decorated = handle_exceptions(default_return=default_return)(decorated) + + if log_perf: + decorated = log_performance(perf_threshold_ms)(decorated) + + if log_entry: + decorated = log_entry_exit(decorated) + + return decorated + + return decorator diff --git a/tests/test_cli/__init__.py b/tests/test_cli/__init__.py new file mode 100644 index 0000000000..fc247f7499 --- /dev/null +++ b/tests/test_cli/__init__.py @@ -0,0 +1 @@ +"""CLI模块单元测试""" diff --git a/tests/test_cli/conftest.py b/tests/test_cli/conftest.py new file mode 100644 index 0000000000..6c803f372a --- /dev/null +++ b/tests/test_cli/conftest.py @@ -0,0 +1,37 @@ +"""CLI测试共享fixtures""" + +import asyncio +from unittest.mock import MagicMock + +import pytest + + +@pytest.fixture +def event_loop(): + """创建事件循环""" + loop = asyncio.new_event_loop() + yield loop + loop.close() + + +@pytest.fixture +def mock_platform_meta(): + """创建模拟的PlatformMetadata""" + meta = MagicMock() + meta.name = "cli" + return meta + + +@pytest.fixture +def mock_output_queue(): + """创建模拟的输出队列""" + return asyncio.Queue() + + +@pytest.fixture +def mock_message_chain(): + """创建模拟的MessageChain""" + chain = MagicMock() + chain.chain = [] + chain.get_plain_text.return_value = "Test response" + return chain diff --git a/tests/test_cli/test_decorators.py b/tests/test_cli/test_decorators.py new file mode 100644 index 0000000000..7b0fae7d26 --- /dev/null +++ b/tests/test_cli/test_decorators.py @@ -0,0 +1,408 @@ +"""AOP装饰器单元测试""" + +import asyncio + +import pytest + + +class TestExceptionClasses: + """异常类测试""" + + def test_cli_error(self): + """测试CLI基础异常""" + from astrbot.core.platform.sources.cli.utils.decorators import CLIError + + error = CLIError("Test error", "TEST_CODE") + assert str(error) == "Test error" + assert error.error_code == "TEST_CODE" + + def test_authentication_error(self): + """测试认证异常""" + from astrbot.core.platform.sources.cli.utils.decorators import ( + AuthenticationError, + ) + + error = AuthenticationError() + assert error.error_code == "AUTH_FAILED" + + error2 = AuthenticationError("Custom message") + assert str(error2) == "Custom message" + + def test_validation_error(self): + """测试验证异常""" + from astrbot.core.platform.sources.cli.utils.decorators import ValidationError + + error = ValidationError() + assert error.error_code == "VALIDATION_ERROR" + + def test_timeout_error(self): + """测试超时异常""" + from astrbot.core.platform.sources.cli.utils.decorators import TimeoutError + + error = TimeoutError() + assert error.error_code == "TIMEOUT" + + +class TestHandleExceptions: + """异常处理装饰器测试""" + + def test_sync_no_exception(self): + """测试同步函数无异常""" + from astrbot.core.platform.sources.cli.utils.decorators import handle_exceptions + + @handle_exceptions() + def func(): + return "success" + + assert func() == "success" + + def test_sync_with_exception(self): + """测试同步函数有异常""" + from astrbot.core.platform.sources.cli.utils.decorators import handle_exceptions + + @handle_exceptions(default_return="default") + def func(): + raise ValueError("test error") + + assert func() == "default" + + def test_sync_reraise(self): + """测试同步函数重新抛出异常""" + from astrbot.core.platform.sources.cli.utils.decorators import handle_exceptions + + @handle_exceptions(reraise=True) + def func(): + raise ValueError("test error") + + with pytest.raises(ValueError): + func() + + @pytest.mark.asyncio + async def test_async_no_exception(self): + """测试异步函数无异常""" + from astrbot.core.platform.sources.cli.utils.decorators import handle_exceptions + + @handle_exceptions() + async def func(): + return "success" + + assert await func() == "success" + + @pytest.mark.asyncio + async def test_async_with_exception(self): + """测试异步函数有异常""" + from astrbot.core.platform.sources.cli.utils.decorators import handle_exceptions + + @handle_exceptions(default_return="default") + async def func(): + raise ValueError("test error") + + assert await func() == "default" + + +class TestRetry: + """重试装饰器测试""" + + def test_sync_success_first_try(self): + """测试同步函数首次成功""" + from astrbot.core.platform.sources.cli.utils.decorators import retry + + call_count = 0 + + @retry(max_attempts=3, delay=0.01) + def func(): + nonlocal call_count + call_count += 1 + return "success" + + assert func() == "success" + assert call_count == 1 + + def test_sync_success_after_retry(self): + """测试同步函数重试后成功""" + from astrbot.core.platform.sources.cli.utils.decorators import retry + + call_count = 0 + + @retry(max_attempts=3, delay=0.01) + def func(): + nonlocal call_count + call_count += 1 + if call_count < 3: + raise ValueError("retry") + return "success" + + assert func() == "success" + assert call_count == 3 + + def test_sync_all_attempts_fail(self): + """测试同步函数所有重试失败""" + from astrbot.core.platform.sources.cli.utils.decorators import retry + + @retry(max_attempts=3, delay=0.01) + def func(): + raise ValueError("always fail") + + with pytest.raises(ValueError): + func() + + @pytest.mark.asyncio + async def test_async_success_after_retry(self): + """测试异步函数重试后成功""" + from astrbot.core.platform.sources.cli.utils.decorators import retry + + call_count = 0 + + @retry(max_attempts=3, delay=0.01) + async def func(): + nonlocal call_count + call_count += 1 + if call_count < 2: + raise ValueError("retry") + return "success" + + assert await func() == "success" + assert call_count == 2 + + +class TestTimeout: + """超时装饰器测试""" + + @pytest.mark.asyncio + async def test_no_timeout(self): + """测试无超时""" + from astrbot.core.platform.sources.cli.utils.decorators import timeout + + @timeout(1.0) + async def func(): + return "success" + + assert await func() == "success" + + @pytest.mark.asyncio + async def test_timeout_exceeded(self): + """测试超时""" + from astrbot.core.platform.sources.cli.utils.decorators import ( + TimeoutError, + timeout, + ) + + @timeout(0.01) + async def func(): + await asyncio.sleep(1.0) + return "success" + + with pytest.raises(TimeoutError): + await func() + + def test_sync_not_supported(self): + """测试同步函数不支持""" + from astrbot.core.platform.sources.cli.utils.decorators import timeout + + with pytest.raises(TypeError): + + @timeout(1.0) + def func(): + return "success" + + +class TestLogEntryExit: + """日志入口出口装饰器测试""" + + def test_sync_function(self): + """测试同步函数""" + from astrbot.core.platform.sources.cli.utils.decorators import log_entry_exit + + @log_entry_exit + def func(): + return "success" + + assert func() == "success" + + @pytest.mark.asyncio + async def test_async_function(self): + """测试异步函数""" + from astrbot.core.platform.sources.cli.utils.decorators import log_entry_exit + + @log_entry_exit + async def func(): + return "success" + + assert await func() == "success" + + def test_sync_with_exception(self): + """测试同步函数异常""" + from astrbot.core.platform.sources.cli.utils.decorators import log_entry_exit + + @log_entry_exit + def func(): + raise ValueError("test") + + with pytest.raises(ValueError): + func() + + +class TestLogPerformance: + """性能日志装饰器测试""" + + def test_sync_under_threshold(self): + """测试同步函数低于阈值""" + from astrbot.core.platform.sources.cli.utils.decorators import log_performance + + @log_performance(threshold_ms=1000.0) + def func(): + return "success" + + assert func() == "success" + + @pytest.mark.asyncio + async def test_async_under_threshold(self): + """测试异步函数低于阈值""" + from astrbot.core.platform.sources.cli.utils.decorators import log_performance + + @log_performance(threshold_ms=1000.0) + async def func(): + return "success" + + assert await func() == "success" + + +class TestRequireAuth: + """权限校验装饰器测试""" + + def test_sync_valid_token(self): + """测试同步函数有效token""" + from astrbot.core.platform.sources.cli.utils.decorators import require_auth + + @require_auth(token_getter=lambda: "valid_token") + def func(auth_token=None): + return "success" + + assert func(auth_token="valid_token") == "success" + + def test_sync_invalid_token(self): + """测试同步函数无效token""" + from astrbot.core.platform.sources.cli.utils.decorators import ( + AuthenticationError, + require_auth, + ) + + @require_auth(token_getter=lambda: "valid_token") + def func(auth_token=None): + return "success" + + with pytest.raises(AuthenticationError): + func(auth_token="wrong_token") + + def test_sync_missing_token(self): + """测试同步函数缺少token""" + from astrbot.core.platform.sources.cli.utils.decorators import ( + AuthenticationError, + require_auth, + ) + + @require_auth(token_getter=lambda: "valid_token") + def func(auth_token=None): + return "success" + + with pytest.raises(AuthenticationError): + func() + + def test_sync_disabled_auth(self): + """测试同步函数禁用验证""" + from astrbot.core.platform.sources.cli.utils.decorators import require_auth + + @require_auth(token_getter=lambda: None) + def func(auth_token=None): + return "success" + + # 禁用验证时任何token都通过 + assert func(auth_token="any") == "success" + assert func() == "success" + + @pytest.mark.asyncio + async def test_async_valid_token(self): + """测试异步函数有效token""" + from astrbot.core.platform.sources.cli.utils.decorators import require_auth + + @require_auth(token_getter=lambda: "valid_token") + async def func(auth_token=None): + return "success" + + assert await func(auth_token="valid_token") == "success" + + +class TestRequireWhitelist: + """白名单校验装饰器测试""" + + def test_sync_in_whitelist(self): + """测试同步函数在白名单中""" + from astrbot.core.platform.sources.cli.utils.decorators import require_whitelist + + @require_whitelist( + whitelist=["user1", "user2"], + id_getter=lambda args, kwargs: kwargs.get("user_id"), + ) + def func(user_id=None): + return "success" + + assert func(user_id="user1") == "success" + + def test_sync_not_in_whitelist(self): + """测试同步函数不在白名单中""" + from astrbot.core.platform.sources.cli.utils.decorators import ( + AuthenticationError, + require_whitelist, + ) + + @require_whitelist( + whitelist=["user1", "user2"], + id_getter=lambda args, kwargs: kwargs.get("user_id"), + ) + def func(user_id=None): + return "success" + + with pytest.raises(AuthenticationError): + func(user_id="user3") + + def test_sync_empty_whitelist(self): + """测试同步函数空白名单（允许所有）""" + from astrbot.core.platform.sources.cli.utils.decorators import require_whitelist + + @require_whitelist(whitelist=[], id_getter=lambda args, kwargs: "any") + def func(): + return "success" + + assert func() == "success" + + +class TestCombinedDecorator: + """组合装饰器测试""" + + def test_with_logging_and_error_handling(self): + """测试组合装饰器""" + from astrbot.core.platform.sources.cli.utils.decorators import ( + with_logging_and_error_handling, + ) + + @with_logging_and_error_handling( + log_entry=True, + handle_errors=True, + default_return="error", + ) + def func(): + raise ValueError("test") + + assert func() == "error" + + def test_with_logging_no_error(self): + """测试组合装饰器无错误""" + from astrbot.core.platform.sources.cli.utils.decorators import ( + with_logging_and_error_handling, + ) + + @with_logging_and_error_handling(log_entry=True, handle_errors=False) + def func(): + return "success" + + assert func() == "success" diff --git a/tests/test_cli/test_e2e.py b/tests/test_cli/test_e2e.py new file mode 100644 index 0000000000..ff2f3ac26e --- /dev/null +++ b/tests/test_cli/test_e2e.py @@ -0,0 +1,288 @@ +"""CLI端到端测试 - 验证完整消息处理流程""" + +import asyncio +import json +from unittest.mock import MagicMock, patch + +import pytest + + +class TestCLIEndToEnd: + """CLI端到端测试类""" + + @pytest.fixture + def mock_context(self): + """创建模拟的上下文""" + ctx = MagicMock() + ctx.register_platform = MagicMock() + return ctx + + @pytest.fixture + def mock_config(self): + """创建模拟的配置""" + return { + "id": "cli_test", + "enable": True, + "mode": "socket", + "socket_type": "tcp", + "tcp_port": 0, + "session_ttl": 30, + "use_isolated_sessions": False, + } + + @pytest.mark.asyncio + async def test_message_converter_to_event_flow(self): + """测试消息转换到事件的完整流程""" + from astrbot.core.platform.platform_metadata import PlatformMetadata + from astrbot.core.platform.sources.cli.cli_event import CLIMessageEvent + from astrbot.core.platform.sources.cli.message.converter import MessageConverter + + # 1. 创建消息转换器 + converter = MessageConverter() + + # 2. 转换输入消息 + message = converter.convert("Hello, AstrBot!") + + # 3. 验证消息结构 + assert message.message_str == "Hello, AstrBot!" + assert message.session_id == "cli_session" + assert message.sender.user_id == "cli_user" + + # 4. 创建事件 + platform_meta = PlatformMetadata( + name="cli", description="CLI Platform", id="cli_test" + ) + output_queue = asyncio.Queue() + + event = CLIMessageEvent( + message_str=message.message_str, + message_obj=message, + platform_meta=platform_meta, + session_id=message.session_id, + output_queue=output_queue, + ) + + # 5. 验证事件属性 + assert event.message_str == "Hello, AstrBot!" + assert event.session_id == "cli_session" + + @pytest.mark.asyncio + async def test_response_builder_with_message_chain(self): + """测试响应构建器处理消息链""" + from astrbot.core.message.components import Image, Plain + from astrbot.core.message.message_event_result import MessageChain + from astrbot.core.platform.sources.cli.message.response_builder import ( + ResponseBuilder, + ) + + # 1. 创建消息链 + chain = MessageChain() + chain.chain = [ + Plain("Hello!"), + Image(file="https://example.com/image.png"), + ] + chain.get_plain_text = MagicMock(return_value="Hello!") + + # 2. 构建响应 + response = ResponseBuilder.build_success(chain, "req123") + result = json.loads(response) + + # 3. 验证响应结构 + assert result["status"] == "success" + assert result["response"] == "Hello!" + assert result["request_id"] == "req123" + assert len(result["images"]) == 1 + assert result["images"][0]["type"] == "url" + assert result["images"][0]["url"] == "https://example.com/image.png" + + @pytest.mark.asyncio + async def test_session_lifecycle(self): + """测试会话生命周期""" + from astrbot.core.platform.sources.cli.session.session_manager import ( + SessionManager, + ) + + # 1. 创建会话管理器（启用） + manager = SessionManager(ttl=30, enabled=True) + + # 2. 注册会话 + manager.register("session_1") + manager.register("session_2") + + # 3. 验证会话存在（通过检查是否过期） + assert manager.is_expired("session_1") is False + assert manager.is_expired("session_2") is False + + # 4. 验证未注册的会话被视为过期 + assert manager.is_expired("nonexistent") is True + + @pytest.mark.asyncio + async def test_token_validation_flow(self): + """测试Token验证流程""" + import tempfile + + from astrbot.core.platform.sources.cli.config.token_manager import TokenManager + + # 使用临时目录避免影响真实token文件 + with tempfile.TemporaryDirectory() as tmpdir: + with patch( + "astrbot.core.platform.sources.cli.config.token_manager.get_astrbot_data_path" + ) as mock_path: + mock_path.return_value = tmpdir + + # 1. 创建Token管理器（会自动生成token） + manager = TokenManager() + token = manager.token + + # 2. 验证token已生成 + assert token is not None + assert len(token) > 0 + + # 3. 验证正确Token + assert manager.validate(token) is True + + # 4. 验证错误Token + assert manager.validate("wrong_token") is False + + # 5. 验证空Token + assert manager.validate("") is False + + @pytest.mark.asyncio + async def test_cli_event_send_to_queue(self): + """测试CLI事件发送到队列""" + from astrbot.core.message.components import Plain + from astrbot.core.message.message_event_result import MessageChain + from astrbot.core.platform.platform_metadata import PlatformMetadata + from astrbot.core.platform.sources.cli.cli_event import CLIMessageEvent + from astrbot.core.platform.sources.cli.message.converter import MessageConverter + + # 1. 使用MessageConverter创建真实的消息对象 + converter = MessageConverter() + message_obj = converter.convert("Test") + + platform_meta = PlatformMetadata( + name="cli", description="CLI Platform", id="cli_test" + ) + output_queue = asyncio.Queue() + + event = CLIMessageEvent( + message_str="Test", + message_obj=message_obj, + platform_meta=platform_meta, + session_id="test_session", + output_queue=output_queue, + ) + + # 2. 创建响应消息链 + response_chain = MessageChain() + response_chain.chain = [Plain("Response")] + + # 3. 发送响应（无response_future时直接放入队列） + result = await event.send(response_chain) + + # 4. 验证结果 + assert result["success"] is True + + # 5. 验证队列中有消息 + queued_message = await output_queue.get() + assert queued_message == response_chain + + @pytest.mark.asyncio + async def test_image_processor_pipeline(self): + """测试图片处理管道""" + import base64 + import os + import tempfile + + from astrbot.core.message.components import Image, Plain + from astrbot.core.platform.sources.cli.message.image_processor import ( + ChainPreprocessor, + ImageExtractor, + ImageProcessor, + ) + + # 1. 创建临时图片文件 + with tempfile.NamedTemporaryFile(delete=False, suffix=".png") as f: + f.write(b"fake image data") + temp_path = f.name + + try: + # 2. 测试本地文件转base64 + base64_data = ImageProcessor.local_file_to_base64(temp_path) + assert base64_data == base64.b64encode(b"fake image data").decode("utf-8") + + # 3. 创建混合消息链 + chain = MagicMock() + chain.chain = [ + Plain("Hello"), + Image(file="https://example.com/remote.png"), + Image(file=f"file:///{temp_path}"), + ] + + # 4. 提取图片信息 + images = ImageExtractor.extract(chain) + assert len(images) == 2 + assert images[0].type == "url" + assert images[0].url == "https://example.com/remote.png" + + # 5. 预处理消息链（本地文件转base64） + local_image = Image(file=f"file:///{temp_path}") + preprocess_chain = MagicMock() + preprocess_chain.chain = [local_image] + + ChainPreprocessor.preprocess(preprocess_chain) + + # 验证本地文件已转换为base64 + assert local_image.file.startswith("base64://") + + finally: + os.unlink(temp_path) + + @pytest.mark.asyncio + async def test_error_response_building(self): + """测试错误响应构建""" + from astrbot.core.platform.sources.cli.message.response_builder import ( + ResponseBuilder, + ) + + # 1. 基本错误 + response = ResponseBuilder.build_error("Something went wrong") + result = json.loads(response) + assert result["status"] == "error" + assert result["error"] == "Something went wrong" + + # 2. 带request_id的错误 + response = ResponseBuilder.build_error("Auth failed", request_id="req123") + result = json.loads(response) + assert result["request_id"] == "req123" + + # 3. 带错误代码的错误 + response = ResponseBuilder.build_error( + "Unauthorized", request_id="req123", error_code="AUTH_FAILED" + ) + result = json.loads(response) + assert result["error_code"] == "AUTH_FAILED" + + @pytest.mark.asyncio + async def test_isolated_session_creation(self): + """测试隔离会话创建""" + from astrbot.core.platform.sources.cli.message.converter import MessageConverter + + converter = MessageConverter() + + # 1. 不启用隔离 + msg1 = converter.convert("Test", request_id="req1", use_isolated_session=False) + assert msg1.session_id == "cli_session" + + # 2. 启用隔离 + msg2 = converter.convert("Test", request_id="req2", use_isolated_session=True) + assert msg2.session_id == "cli_session_req2" + + # 3. 启用隔离但无request_id + msg3 = converter.convert("Test", request_id=None, use_isolated_session=True) + assert msg3.session_id == "cli_session" + + # 4. 不同request_id产生不同session + msg4 = converter.convert("Test", request_id="req3", use_isolated_session=True) + assert msg4.session_id == "cli_session_req3" + assert msg2.session_id != msg4.session_id diff --git a/tests/test_cli/test_image_processor.py b/tests/test_cli/test_image_processor.py new file mode 100644 index 0000000000..86242e6983 --- /dev/null +++ b/tests/test_cli/test_image_processor.py @@ -0,0 +1,241 @@ +"""ImageProcessor 单元测试""" + +import base64 +import os +import tempfile +from unittest.mock import MagicMock, patch + + +class TestImageCodec: + """ImageCodec 测试类""" + + def test_encode(self): + """测试 base64 编码""" + from astrbot.core.platform.sources.cli.message.image_processor import ImageCodec + + data = b"Hello, World!" + encoded = ImageCodec.encode(data) + assert encoded == base64.b64encode(data).decode("utf-8") + + def test_decode(self): + """测试 base64 解码""" + from astrbot.core.platform.sources.cli.message.image_processor import ImageCodec + + original = b"Hello, World!" + encoded = base64.b64encode(original).decode("utf-8") + decoded = ImageCodec.decode(encoded) + assert decoded == original + + +class TestImageFileIO: + """ImageFileIO 测试类""" + + def test_read_existing_file(self): + """测试读取存在的文件""" + from astrbot.core.platform.sources.cli.message.image_processor import ( + ImageFileIO, + ) + + with tempfile.NamedTemporaryFile(delete=False) as f: + f.write(b"test content") + temp_path = f.name + + try: + data = ImageFileIO.read(temp_path) + assert data == b"test content" + finally: + os.unlink(temp_path) + + def test_read_nonexistent_file(self): + """测试读取不存在的文件""" + from astrbot.core.platform.sources.cli.message.image_processor import ( + ImageFileIO, + ) + + data = ImageFileIO.read("/nonexistent/path/file.png") + assert data is None + + def test_write_temp(self): + """测试写入临时文件""" + from astrbot.core.platform.sources.cli.message.image_processor import ( + ImageFileIO, + ) + + with patch( + "astrbot.core.platform.sources.cli.message.image_processor.get_astrbot_temp_path" + ) as mock_temp: + mock_temp.return_value = tempfile.gettempdir() + + data = b"test image data" + temp_path = ImageFileIO.write_temp(data, suffix=".png") + + assert temp_path is not None + assert os.path.exists(temp_path) + + with open(temp_path, "rb") as f: + assert f.read() == data + + os.unlink(temp_path) + + +class TestImageInfo: + """ImageInfo 测试类""" + + def test_to_dict_url(self): + """测试 URL 类型转字典""" + from astrbot.core.platform.sources.cli.message.image_processor import ImageInfo + + info = ImageInfo(type="url", url="https://example.com/image.png") + result = info.to_dict() + + assert result["type"] == "url" + assert result["url"] == "https://example.com/image.png" + + def test_to_dict_file(self): + """测试文件类型转字典""" + from astrbot.core.platform.sources.cli.message.image_processor import ImageInfo + + info = ImageInfo(type="file", path="/path/to/image.png", size=1024) + result = info.to_dict() + + assert result["type"] == "file" + assert result["path"] == "/path/to/image.png" + assert result["size"] == 1024 + + def test_to_dict_with_error(self): + """测试带错误信息转字典""" + from astrbot.core.platform.sources.cli.message.image_processor import ImageInfo + + info = ImageInfo(type="file", error="Failed to read") + result = info.to_dict() + + assert result["error"] == "Failed to read" + + +class TestImageExtractor: + """ImageExtractor 测试类""" + + def test_extract_url_image(self): + """测试提取 URL 图片""" + from astrbot.core.message.components import Image + from astrbot.core.platform.sources.cli.message.image_processor import ( + ImageExtractor, + ) + + chain = MagicMock() + chain.chain = [Image(file="https://example.com/image.png")] + + images = ImageExtractor.extract(chain) + + assert len(images) == 1 + assert images[0].type == "url" + assert images[0].url == "https://example.com/image.png" + + def test_extract_empty_chain(self): + """测试提取空消息链""" + from astrbot.core.platform.sources.cli.message.image_processor import ( + ImageExtractor, + ) + + chain = MagicMock() + chain.chain = [] + + images = ImageExtractor.extract(chain) + assert len(images) == 0 + + def test_extract_mixed_components(self): + """测试提取混合组件""" + from astrbot.core.message.components import Image, Plain + from astrbot.core.platform.sources.cli.message.image_processor import ( + ImageExtractor, + ) + + chain = MagicMock() + chain.chain = [ + Plain("Hello"), + Image(file="https://example.com/1.png"), + Plain("World"), + Image(file="https://example.com/2.png"), + ] + + images = ImageExtractor.extract(chain) + + assert len(images) == 2 + assert images[0].url == "https://example.com/1.png" + assert images[1].url == "https://example.com/2.png" + + +class TestChainPreprocessor: + """ChainPreprocessor 测试类""" + + def test_preprocess_local_file(self): + """测试预处理本地文件图片""" + from astrbot.core.message.components import Image + from astrbot.core.platform.sources.cli.message.image_processor import ( + ChainPreprocessor, + ) + + # 创建临时图片文件 + with tempfile.NamedTemporaryFile(delete=False, suffix=".png") as f: + f.write(b"fake image data") + temp_path = f.name + + try: + chain = MagicMock() + image = Image(file=f"file:///{temp_path}") + chain.chain = [image] + + ChainPreprocessor.preprocess(chain) + + # 验证已转换为 base64 + assert image.file.startswith("base64://") + base64_data = image.file[9:] + decoded = base64.b64decode(base64_data) + assert decoded == b"fake image data" + finally: + os.unlink(temp_path) + + def test_preprocess_url_unchanged(self): + """测试 URL 图片不变""" + from astrbot.core.message.components import Image + from astrbot.core.platform.sources.cli.message.image_processor import ( + ChainPreprocessor, + ) + + chain = MagicMock() + image = Image(file="https://example.com/image.png") + chain.chain = [image] + + ChainPreprocessor.preprocess(chain) + + # URL 应保持不变 + assert image.file == "https://example.com/image.png" + + +class TestImageProcessor: + """ImageProcessor 门面测试类""" + + def test_local_file_to_base64(self): + """测试本地文件转 base64""" + from astrbot.core.platform.sources.cli.message.image_processor import ( + ImageProcessor, + ) + + with tempfile.NamedTemporaryFile(delete=False) as f: + f.write(b"test data") + temp_path = f.name + + try: + result = ImageProcessor.local_file_to_base64(temp_path) + assert result == base64.b64encode(b"test data").decode("utf-8") + finally: + os.unlink(temp_path) + + def test_local_file_to_base64_nonexistent(self): + """测试不存在的文件""" + from astrbot.core.platform.sources.cli.message.image_processor import ( + ImageProcessor, + ) + + result = ImageProcessor.local_file_to_base64("/nonexistent/file.png") + assert result is None diff --git a/tests/test_cli/test_message_converter.py b/tests/test_cli/test_message_converter.py new file mode 100644 index 0000000000..838d9a723c --- /dev/null +++ b/tests/test_cli/test_message_converter.py @@ -0,0 +1,91 @@ +"""MessageConverter 单元测试""" + + +import pytest + + +class TestMessageConverter: + """MessageConverter 测试类""" + + @pytest.fixture + def converter(self): + """创建 MessageConverter 实例""" + from astrbot.core.platform.sources.cli.message.converter import MessageConverter + + return MessageConverter() + + def test_convert_basic_text(self, converter): + """测试基本文本转换""" + message = converter.convert("Hello, World!") + + assert message.message_str == "Hello, World!" + assert message.self_id == "cli_bot" + assert message.session_id == "cli_session" + assert message.sender.user_id == "cli_user" + assert message.sender.nickname == "CLI User" + + def test_convert_with_request_id_no_isolation(self, converter): + """测试带 request_id 但不启用隔离""" + message = converter.convert( + "Test", request_id="req123", use_isolated_session=False + ) + + # 不启用隔离时，使用默认 session_id + assert message.session_id == "cli_session" + + def test_convert_with_isolated_session(self, converter): + """测试启用会话隔离""" + message = converter.convert( + "Test", request_id="req123", use_isolated_session=True + ) + + # 启用隔离时，session_id 包含 request_id + assert message.session_id == "cli_session_req123" + + def test_convert_isolated_without_request_id(self, converter): + """测试启用隔离但无 request_id""" + message = converter.convert("Test", request_id=None, use_isolated_session=True) + + # 无 request_id 时，使用默认 session_id + assert message.session_id == "cli_session" + + def test_convert_message_has_id(self, converter): + """测试消息有唯一 ID""" + message1 = converter.convert("Test1") + message2 = converter.convert("Test2") + + assert message1.message_id is not None + assert message2.message_id is not None + assert message1.message_id != message2.message_id + + def test_convert_message_has_plain_component(self, converter): + """测试消息包含 Plain 组件""" + from astrbot.core.message.components import Plain + + message = converter.convert("Hello") + + assert len(message.message) == 1 + assert isinstance(message.message[0], Plain) + assert message.message[0].text == "Hello" + + def test_custom_default_session_id(self): + """测试自定义默认 session_id""" + from astrbot.core.platform.sources.cli.message.converter import MessageConverter + + converter = MessageConverter(default_session_id="custom_session") + message = converter.convert("Test") + + assert message.session_id == "custom_session" + + def test_custom_user_info(self): + """测试自定义用户信息""" + from astrbot.core.platform.sources.cli.message.converter import MessageConverter + + converter = MessageConverter( + user_id="custom_user", + user_nickname="Custom User", + ) + message = converter.convert("Test") + + assert message.sender.user_id == "custom_user" + assert message.sender.nickname == "Custom User" diff --git a/tests/test_cli/test_response_builder.py b/tests/test_cli/test_response_builder.py new file mode 100644 index 0000000000..31a7a4f3de --- /dev/null +++ b/tests/test_cli/test_response_builder.py @@ -0,0 +1,115 @@ +"""ResponseBuilder 单元测试""" + +import json +from unittest.mock import MagicMock + +import pytest + + +class TestResponseBuilder: + """ResponseBuilder 测试类""" + + @pytest.fixture + def mock_message_chain(self): + """创建模拟的 MessageChain""" + chain = MagicMock() + chain.get_plain_text.return_value = "Hello, World!" + chain.chain = [] + return chain + + def test_build_success_basic(self, mock_message_chain): + """测试构建基本成功响应""" + from astrbot.core.platform.sources.cli.message.response_builder import ( + ResponseBuilder, + ) + + response = ResponseBuilder.build_success(mock_message_chain, "req123") + result = json.loads(response) + + assert result["status"] == "success" + assert result["response"] == "Hello, World!" + assert result["request_id"] == "req123" + assert result["images"] == [] + + def test_build_success_with_extra(self, mock_message_chain): + """测试构建带额外字段的成功响应""" + from astrbot.core.platform.sources.cli.message.response_builder import ( + ResponseBuilder, + ) + + extra = {"custom_field": "custom_value"} + response = ResponseBuilder.build_success(mock_message_chain, "req123", extra) + result = json.loads(response) + + assert result["custom_field"] == "custom_value" + + def test_build_error_basic(self): + """测试构建基本错误响应""" + from astrbot.core.platform.sources.cli.message.response_builder import ( + ResponseBuilder, + ) + + response = ResponseBuilder.build_error("Something went wrong") + result = json.loads(response) + + assert result["status"] == "error" + assert result["error"] == "Something went wrong" + assert "request_id" not in result + + def test_build_error_with_request_id(self): + """测试构建带 request_id 的错误响应""" + from astrbot.core.platform.sources.cli.message.response_builder import ( + ResponseBuilder, + ) + + response = ResponseBuilder.build_error("Error", request_id="req123") + result = json.loads(response) + + assert result["request_id"] == "req123" + + def test_build_error_with_error_code(self): + """测试构建带错误代码的错误响应""" + from astrbot.core.platform.sources.cli.message.response_builder import ( + ResponseBuilder, + ) + + response = ResponseBuilder.build_error( + "Unauthorized", request_id="req123", error_code="AUTH_FAILED" + ) + result = json.loads(response) + + assert result["error_code"] == "AUTH_FAILED" + + def test_build_success_with_url_image(self): + """测试构建带 URL 图片的成功响应""" + from astrbot.core.message.components import Image + from astrbot.core.platform.sources.cli.message.response_builder import ( + ResponseBuilder, + ) + + chain = MagicMock() + chain.get_plain_text.return_value = "Image response" + + # 创建 URL 图片组件 + image = Image(file="https://example.com/image.png") + chain.chain = [image] + + response = ResponseBuilder.build_success(chain, "req123") + result = json.loads(response) + + assert len(result["images"]) == 1 + assert result["images"][0]["type"] == "url" + assert result["images"][0]["url"] == "https://example.com/image.png" + + def test_build_success_chinese_text(self, mock_message_chain): + """测试构建中文文本响应""" + from astrbot.core.platform.sources.cli.message.response_builder import ( + ResponseBuilder, + ) + + mock_message_chain.get_plain_text.return_value = "你好，世界！" + + response = ResponseBuilder.build_success(mock_message_chain, "req123") + result = json.loads(response) + + assert result["response"] == "你好，世界！" diff --git a/tests/test_cli/test_token_manager.py b/tests/test_cli/test_token_manager.py new file mode 100644 index 0000000000..897e3855d5 --- /dev/null +++ b/tests/test_cli/test_token_manager.py @@ -0,0 +1,114 @@ +"""TokenManager 单元测试""" + +import os +import tempfile +from unittest.mock import patch + +import pytest + + +class TestTokenManager: + """TokenManager 测试类""" + + @pytest.fixture + def temp_data_path(self): + """创建临时数据目录""" + with tempfile.TemporaryDirectory() as tmpdir: + yield tmpdir + + @pytest.fixture + def token_manager(self, temp_data_path): + """创建 TokenManager 实例""" + with patch( + "astrbot.core.platform.sources.cli.config.token_manager.get_astrbot_data_path", + return_value=temp_data_path, + ): + from astrbot.core.platform.sources.cli.config.token_manager import ( + TokenManager, + ) + + return TokenManager() + + def test_generate_new_token(self, token_manager, temp_data_path): + """测试首次生成 Token""" + token = token_manager.token + assert token is not None + assert len(token) > 0 + + # 验证 Token 文件已创建 + token_file = os.path.join(temp_data_path, ".cli_token") + assert os.path.exists(token_file) + + def test_load_existing_token(self, temp_data_path): + """测试加载已存在的 Token""" + # 预先写入 Token + token_file = os.path.join(temp_data_path, ".cli_token") + expected_token = "test_token_12345" + with open(token_file, "w", encoding="utf-8") as f: + f.write(expected_token) + + with patch( + "astrbot.core.platform.sources.cli.config.token_manager.get_astrbot_data_path", + return_value=temp_data_path, + ): + from astrbot.core.platform.sources.cli.config.token_manager import ( + TokenManager, + ) + + manager = TokenManager() + assert manager.token == expected_token + + def test_validate_correct_token(self, token_manager): + """测试验证正确的 Token""" + token = token_manager.token + assert token_manager.validate(token) is True + + def test_validate_wrong_token(self, token_manager): + """测试验证错误的 Token""" + _ = token_manager.token # 确保 Token 已生成 + assert token_manager.validate("wrong_token") is False + + def test_validate_empty_token(self, token_manager): + """测试验证空 Token""" + _ = token_manager.token # 确保 Token 已生成 + assert token_manager.validate("") is False + + def test_validate_without_server_token(self, temp_data_path): + """测试服务器无 Token 时跳过验证""" + with patch( + "astrbot.core.platform.sources.cli.config.token_manager.get_astrbot_data_path", + return_value=temp_data_path, + ): + from astrbot.core.platform.sources.cli.config.token_manager import ( + TokenManager, + ) + + manager = TokenManager() + # 模拟 _ensure_token 返回 None（Token 生成失败场景） + with patch.object(manager, "_ensure_token", return_value=None): + manager._token = None # 重置缓存 + + # 无 Token 时应跳过验证 + assert manager.validate("any_token") is True + + def test_regenerate_empty_token_file(self, temp_data_path): + """测试空 Token 文件时重新生成""" + # 创建空 Token 文件 + token_file = os.path.join(temp_data_path, ".cli_token") + with open(token_file, "w", encoding="utf-8") as f: + f.write("") + + with patch( + "astrbot.core.platform.sources.cli.config.token_manager.get_astrbot_data_path", + return_value=temp_data_path, + ): + from astrbot.core.platform.sources.cli.config.token_manager import ( + TokenManager, + ) + + manager = TokenManager() + token = manager.token + + # 应该生成新 Token + assert token is not None + assert len(token) > 0 From b8eb38a40721eb75023adcfae07fa1e1a37cf234 Mon Sep 17 00:00:00 2001 From: YukiRa1n <167516635+YukiRa1n@users.noreply.github.com> Date: Thu, 5 Feb 2026 21:15:12 +0800 Subject: [PATCH 10/39] =?UTF-8?q?feat:=20=E6=B7=BB=E5=8A=A0=20`astr`=20CLI?= =?UTF-8?q?=20=E5=AE=A2=E6=88=B7=E7=AB=AF=E5=91=BD=E4=BB=A4?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit 新增 `astr` 命令作为 CLI Platform 的客户端工具，用于快速测试和调试。 功能: - `astr "消息"` - 发送消息到 CLI Platform - `astr --log` - 获取控制台日志 - `astr --log --lines N --level LEVEL --pattern PATTERN` - 日志过滤 变更: - 新增 `astrbot/cli/client/` 包 - `__init__.py` - 包入口 - `__main__.py` - Socket 客户端实现（日志抑制、token 自动认证、日志获取） - 修改 `pyproject.toml` - 添加 `astr` 命令入口点 - 修改 `socket_handler.py` - 添加 `_get_logs()` 方法处理日志请求 - 修改 `cli_adapter.py` - 传递 data_path 给 SocketClientHandler 安全: - 所有请求（包括获取日志）都需要 token 认证 - Token 从 `data/.cli_token` 自动读取 --- astrbot/cli/client/__init__.py | 4 + astrbot/cli/client/__main__.py | 457 ++++++++++++++++++ .../core/platform/sources/cli/cli_adapter.py | 1 + .../sources/cli/handlers/socket_handler.py | 91 +++- pyproject.toml | 1 + 5 files changed, 550 insertions(+), 4 deletions(-) create mode 100644 astrbot/cli/client/__init__.py create mode 100644 astrbot/cli/client/__main__.py diff --git a/astrbot/cli/client/__init__.py b/astrbot/cli/client/__init__.py new file mode 100644 index 0000000000..9ef8b3c4e6 --- /dev/null +++ b/astrbot/cli/client/__init__.py @@ -0,0 +1,4 @@ +"""AstrBot CLI Client - Socket客户端工具 + +用于通过Unix Socket或TCP Socket与AstrBot CLIPlatformAdapter通信 +""" diff --git a/astrbot/cli/client/__main__.py b/astrbot/cli/client/__main__.py new file mode 100644 index 0000000000..4f269c787b --- /dev/null +++ b/astrbot/cli/client/__main__.py @@ -0,0 +1,457 @@ +#!/usr/bin/env python3 +""" +AstrBot CLI Client - 跨平台Socket客户端 + +支持Unix Socket和TCP Socket连接到CLIPlatformAdapter + +用法: + astr "你好" + astr "/help" + echo "你好" | astr +""" + +# 抑制框架导入时的日志输出（必须在所有导入之前执行） +import logging + +# 禁用所有 astrbot 相关日志 +logging.getLogger("astrbot").setLevel(logging.CRITICAL + 1) +logging.getLogger("astrbot.core").setLevel(logging.CRITICAL + 1) +# 禁用根日志记录器的控制台输出 +root = logging.getLogger() +root.setLevel(logging.CRITICAL + 1) +# 移除可能存在的控制台处理器 +for handler in root.handlers[:]: + if isinstance(handler, logging.StreamHandler): + root.removeHandler(handler) + +import argparse +import io +import json +import os +import socket +import sys +import uuid +from typing import Optional + +# 仅使用标准库导入，不导入astrbot框架 +# Windows UTF-8 输出支持 +if sys.platform == "win32": + # 设置stdout/stderr为UTF-8编码 + sys.stdout = io.TextIOWrapper(sys.stdout.buffer, encoding="utf-8", errors="replace") + sys.stderr = io.TextIOWrapper(sys.stderr.buffer, encoding="utf-8", errors="replace") + + +def get_data_path() -> str: + """获取数据目录路径（复制自 astrbot.core.utils.astrbot_path.get_astrbot_data_path） + + 优先级： + 1. 环境变量 ASTRBOT_ROOT + 2. 当前工作目录 + """ + # 获取根目录 + if root := os.environ.get("ASTRBOT_ROOT"): + root_path = os.path.realpath(root) + else: + root_path = os.path.realpath(os.getcwd()) + + return os.path.join(root_path, "data") + + +def get_temp_path() -> str: + """获取临时目录路径,兼容容器和非容器环境""" + # 优先使用环境变量 + if root := os.environ.get("ASTRBOT_ROOT"): + return os.path.join(root, "data", "temp") + # 默认使用系统临时目录 + return "/tmp" + + +def load_auth_token() -> str: + """从密钥文件加载认证token + + Returns: + token字符串,如果文件不存在则返回空字符串 + """ + token_file = os.path.join(get_data_path(), ".cli_token") + try: + with open(token_file, encoding="utf-8") as f: + return f.read().strip() + except FileNotFoundError: + return "" + except Exception: + return "" + + +def load_connection_info(data_dir: str) -> Optional[dict]: + """加载连接信息 + + 从.cli_connection文件读取Socket连接信息 + + Args: + data_dir: 数据目录路径 + + Returns: + 连接信息字典，如果文件不存在则返回None + + Example: + Unix Socket: {"type": "unix", "path": "/tmp/astrbot.sock"} + TCP Socket: {"type": "tcp", "host": "127.0.0.1", "port": 12345} + """ + connection_file = os.path.join(data_dir, ".cli_connection") + try: + with open(connection_file, encoding="utf-8") as f: + connection_info = json.load(f) + return connection_info + except FileNotFoundError: + return None + except json.JSONDecodeError as e: + print( + f"[ERROR] Invalid JSON in connection file: {connection_file}", + file=sys.stderr, + ) + print(f"[ERROR] {e}", file=sys.stderr) + return None + except Exception as e: + print( + f"[ERROR] Failed to load connection info: {e}", + file=sys.stderr, + ) + return None + + +def connect_to_server(connection_info: dict, timeout: float = 30.0) -> socket.socket: + """连接到服务器 + + 根据连接信息类型选择Unix Socket或TCP Socket连接 + + Args: + connection_info: 连接信息字典 + timeout: 超时时间（秒） + + Returns: + socket连接对象 + + Raises: + ValueError: 无效的连接类型 + ConnectionError: 连接失败 + """ + socket_type = connection_info.get("type") + + if socket_type == "unix": + # Unix Socket连接 + socket_path = connection_info.get("path") + if not socket_path: + raise ValueError("Unix socket path is missing in connection info") + + try: + client_socket = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM) + client_socket.settimeout(timeout) + client_socket.connect(socket_path) + return client_socket + except FileNotFoundError: + raise ConnectionError( + f"Socket file not found: {socket_path}. Is AstrBot running?" + ) + except ConnectionRefusedError: + raise ConnectionError( + "Connection refused. Is AstrBot running in socket mode?" + ) + except Exception as e: + raise ConnectionError(f"Unix socket connection error: {e}") + + elif socket_type == "tcp": + # TCP Socket连接 + host = connection_info.get("host") + port = connection_info.get("port") + if not host or not port: + raise ValueError("TCP host or port is missing in connection info") + + try: + client_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM) + client_socket.settimeout(timeout) + client_socket.connect((host, port)) + return client_socket + except ConnectionRefusedError: + raise ConnectionError( + f"Connection refused to {host}:{port}. Is AstrBot running?" + ) + except socket.timeout: + raise ConnectionError(f"Connection timeout to {host}:{port}") + except Exception as e: + raise ConnectionError(f"TCP socket connection error: {e}") + + else: + raise ValueError( + f"Invalid socket type: {socket_type}. Expected 'unix' or 'tcp'" + ) + + +def send_message( + message: str, socket_path: str | None = None, timeout: float = 30.0 +) -> dict: + """发送消息到AstrBot并获取响应 + + 支持自动检测连接类型（Unix Socket或TCP Socket） + + Args: + message: 要发送的消息 + socket_path: Unix socket路径(仅用于向后兼容，优先使用.cli_connection) + timeout: 超时时间（秒） + + Returns: + 响应字典 + """ + data_dir = get_data_path() + + # 加载认证token + auth_token = load_auth_token() + + # 创建请求 + request = {"message": message, "request_id": str(uuid.uuid4())} + + # 如果token存在,添加到请求中 + if auth_token: + request["auth_token"] = auth_token + + # 尝试加载连接信息 + connection_info = load_connection_info(data_dir) + + # 连接到服务器 + try: + if connection_info is not None: + # 使用连接信息文件 + client_socket = connect_to_server(connection_info, timeout) + else: + # 向后兼容：使用默认Unix Socket路径 + if socket_path is None: + socket_path = os.path.join(get_temp_path(), "astrbot.sock") + + fallback_info = {"type": "unix", "path": socket_path} + client_socket = connect_to_server(fallback_info, timeout) + + except (ValueError, ConnectionError) as e: + return {"status": "error", "error": str(e)} + except Exception as e: + return {"status": "error", "error": f"Connection error: {e}"} + + try: + # 发送请求 + request_data = json.dumps(request, ensure_ascii=False).encode("utf-8") + client_socket.sendall(request_data) + + # 接收响应（循环接收所有数据，支持大响应如base64图片） + response_data = b"" + while True: + chunk = client_socket.recv(4096) + if not chunk: + break + response_data += chunk + # 尝试解析JSON，如果成功说明接收完整 + try: + response = json.loads(response_data.decode("utf-8")) + return response + except json.JSONDecodeError: + # JSON不完整，继续接收 + continue + + # 如果循环结束仍未成功解析，尝试最后一次 + response = json.loads(response_data.decode("utf-8")) + return response + + except TimeoutError: + return {"status": "error", "error": "Request timeout"} + except Exception as e: + return {"status": "error", "error": f"Communication error: {e}"} + finally: + client_socket.close() + + +def get_logs( + socket_path: str | None = None, + timeout: float = 30.0, + lines: int = 100, + level: str = "", + pattern: str = "", +) -> dict: + """获取AstrBot日志 + + Args: + socket_path: Socket路径 + timeout: 超时时间 + lines: 返回的日志行数 + level: 日志级别过滤 + pattern: 模式过滤 + + Returns: + 响应字典 + """ + data_dir = get_data_path() + + # 加载认证token + auth_token = load_auth_token() + + # 创建请求 + request = { + "action": "get_logs", + "request_id": str(uuid.uuid4()), + "lines": lines, + "level": level, + "pattern": pattern, + } + + # 添加token + if auth_token: + request["auth_token"] = auth_token + + # 加载连接信息 + connection_info = load_connection_info(data_dir) + + # 连接到服务器 + try: + if connection_info is not None: + client_socket = connect_to_server(connection_info, timeout) + else: + if socket_path is None: + socket_path = os.path.join(get_temp_path(), "astrbot.sock") + fallback_info = {"type": "unix", "path": socket_path} + client_socket = connect_to_server(fallback_info, timeout) + + except (ValueError, ConnectionError) as e: + return {"status": "error", "error": str(e)} + except Exception as e: + return {"status": "error", "error": f"Connection error: {e}"} + + try: + # 发送请求 + request_data = json.dumps(request, ensure_ascii=False).encode("utf-8") + client_socket.sendall(request_data) + + # 接收响应 + response_data = b"" + while True: + chunk = client_socket.recv(4096) + if not chunk: + break + response_data += chunk + try: + response = json.loads(response_data.decode("utf-8")) + return response + except json.JSONDecodeError: + continue + + response = json.loads(response_data.decode("utf-8")) + return response + + except TimeoutError: + return {"status": "error", "error": "Request timeout"} + except Exception as e: + return {"status": "error", "error": f"Communication error: {e}"} + finally: + client_socket.close() + + +def main() -> None: + """主函数""" + parser = argparse.ArgumentParser( + description="AstrBot CLI Client - Send messages to AstrBot CLI Platform (Unix Socket or TCP Socket)", + formatter_class=argparse.RawDescriptionHelpFormatter, + epilog=""" +Examples: + astr "你好" + astr "/help" + astr --socket /tmp/custom.sock "测试消息" + echo "你好" | astr + +Connection: + Automatically detects connection type from .cli_connection file. + Falls back to default Unix Socket if file not found. + """, + ) + + parser.add_argument( + "message", nargs="?", help="Message to send (if not provided, read from stdin)" + ) + + parser.add_argument( + "-s", + "--socket", + default=None, + help="Unix socket path (default: {temp_dir}/astrbot.sock)", + ) + + parser.add_argument( + "-t", + "--timeout", + type=float, + default=30.0, + help="Timeout in seconds (default: 30.0)", + ) + + parser.add_argument( + "-j", "--json", action="store_true", help="Output raw JSON response" + ) + + parser.add_argument( + "--log", + action="store_true", + help="Get recent console logs (instead of sending a message)", + ) + + parser.add_argument( + "--lines", + type=int, + default=100, + help="Number of log lines to return (default: 100, max: 1000)", + ) + + parser.add_argument( + "--level", + default="", + help="Filter logs by level (DEBUG/INFO/WARNING/ERROR/CRITICAL)", + ) + + parser.add_argument( + "--pattern", + default="", + help="Filter logs by pattern (substring match)", + ) + + args = parser.parse_args() + + # 处理日志请求 + if args.log: + response = get_logs(args.socket, args.timeout, args.lines, args.level, args.pattern) + else: + # 处理消息发送 + # 获取消息内容 + if args.message: + message = args.message + elif not sys.stdin.isatty(): + # 从stdin读取 + message = sys.stdin.read().strip() + else: + parser.print_help() + sys.exit(1) + + if not message: + print("Error: Empty message", file=sys.stderr) + sys.exit(1) + + response = send_message(message, args.socket, args.timeout) + + # 输出响应 + if args.json: + # 输出原始JSON + print(json.dumps(response, ensure_ascii=False, indent=2)) + else: + # 格式化输出 + if response.get("status") == "success": + print(response.get("response", "")) + else: + error = response.get("error", "Unknown error") + print(f"Error: {error}", file=sys.stderr) + sys.exit(1) + + +if __name__ == "__main__": + main() diff --git a/astrbot/core/platform/sources/cli/cli_adapter.py b/astrbot/core/platform/sources/cli/cli_adapter.py index 0c2550dc3a..c62dc2d12b 100644 --- a/astrbot/core/platform/sources/cli/cli_adapter.py +++ b/astrbot/core/platform/sources/cli/cli_adapter.py @@ -147,6 +147,7 @@ async def _run_socket_mode(self) -> None: output_queue=self._output_queue, event_committer=self.commit_event, use_isolated_sessions=self.config.use_isolated_sessions, + data_path=get_astrbot_data_path(), ) self._handler = SocketModeHandler( diff --git a/astrbot/core/platform/sources/cli/handlers/socket_handler.py b/astrbot/core/platform/sources/cli/handlers/socket_handler.py index 9ebecf4af3..2c60348def 100644 --- a/astrbot/core/platform/sources/cli/handlers/socket_handler.py +++ b/astrbot/core/platform/sources/cli/handlers/socket_handler.py @@ -5,6 +5,7 @@ import asyncio import json +import os import uuid from collections.abc import Callable from typing import TYPE_CHECKING @@ -43,6 +44,7 @@ def __init__( output_queue: asyncio.Queue, event_committer: Callable[["CLIMessageEvent"], None], use_isolated_sessions: bool = False, + data_path: str | None = None, ): """初始化Socket客户端处理器""" self.token_manager = token_manager @@ -52,6 +54,7 @@ def __init__( self.output_queue = output_queue self.event_committer = event_committer self.use_isolated_sessions = use_isolated_sessions + self.data_path = data_path or os.path.join(os.getcwd(), "data") async def handle(self, client_socket) -> None: """处理单个客户端连接""" @@ -73,11 +76,10 @@ async def handle(self, client_socket) -> None: ) return - message_text = request.get("message", "") request_id = request.get("request_id", str(uuid.uuid4())) auth_token = request.get("auth_token", "") - # Token验证 + # Token验证（所有请求都需要token） if not self.token_manager.validate(auth_token): error_msg = ( "Unauthorized: missing token" @@ -91,8 +93,15 @@ async def handle(self, client_socket) -> None: ) return - # 处理消息 - response = await self._process_message(message_text, request_id) + # 处理请求 + if action == "get_logs": + # 获取日志 + response = await self._get_logs(request, request_id) + else: + # 处理消息 + message_text = request.get("message", "") + response = await self._process_message(message_text, request_id) + await self._send_response(loop, client_socket, response) except Exception as e: @@ -180,6 +189,80 @@ async def _process_message(self, message_text: str, request_id: str) -> str: message_event._response_delay_task.cancel() return ResponseBuilder.build_error("Request timeout", request_id, "TIMEOUT") + async def _get_logs(self, request: dict, request_id: str) -> str: + """获取日志 + + Args: + request: 请求字典，支持参数: + - lines: 返回最近N行日志（默认100） + - level: 过滤日志级别 (DEBUG/INFO/WARNING/ERROR/CRITICAL) + - pattern: 过滤包含指定字符串的日志 + request_id: 请求ID + + Returns: + JSON格式的响应字符串 + """ + try: + # 获取参数 + lines = min(request.get("lines", 100), 1000) # 最多1000行 + level_filter = request.get("level", "").upper() + pattern = request.get("pattern", "") + + # 日志文件路径 + log_path = os.path.join(self.data_path, "logs", "astrbot.log") + + if not os.path.exists(log_path): + return ResponseBuilder.build_success( + "", request_id, message="Log file not found" + ) + + # 读取日志文件（从末尾开始） + logs = [] + try: + with open(log_path, "r", encoding="utf-8", errors="ignore") as f: + # 读取所有行 + all_lines = f.readlines() + + # 从末尾开始筛选 + for line in reversed(all_lines): + # 跳过空行 + if not line.strip(): + continue + + # 级别过滤 + if level_filter and level_filter not in line: + continue + + # 模式过滤 + if pattern and pattern not in line: + continue + + logs.append(line.rstrip()) + + if len(logs) >= lines: + break + + except OSError as e: + logger.warning("Failed to read log file: %s", e) + return ResponseBuilder.build_error( + f"Failed to read log file: {e}", request_id + ) + + # 反转回来（使时间顺序正确） + logs.reverse() + + # 构建响应 + log_text = "\n".join(logs) + return ResponseBuilder.build_success( + log_text, request_id, message=f"Retrieved {len(logs)} log lines" + ) + + except Exception as e: + logger.exception("Error getting logs") + return ResponseBuilder.build_error( + f"Error getting logs: {e}", request_id + ) + class SocketModeHandler(IHandler): """Socket模式处理器 diff --git a/pyproject.toml b/pyproject.toml index 9e421c3038..82fb0d33e2 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -76,6 +76,7 @@ dev = [ [project.scripts] astrbot = "astrbot.cli.__main__:cli" +astr = "astrbot.cli.client.__main__:main" [tool.ruff] exclude = ["astrbot/core/utils/t2i/local_strategy.py", "astrbot/api/all.py", "tests"] From ec03c311a6b5616b59c6a899b4cd3bb654d0d122 Mon Sep 17 00:00:00 2001 From: YukiRa1n <167516635+YukiRa1n@users.noreply.github.com> Date: Thu, 5 Feb 2026 21:17:07 +0800 Subject: [PATCH 11/39] =?UTF-8?q?chore:=20=E5=88=A0=E9=99=A4=E7=8B=AC?= =?UTF-8?q?=E7=AB=8B=E7=9A=84=20=20=E8=84=9A=E6=9C=AC?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit 已被 usage: astr [-h] [-s SOCKET] [-t TIMEOUT] [-j] [--log] [--lines LINES] [--level LEVEL] [--pattern PATTERN] [message] AstrBot CLI Client - Send messages to AstrBot CLI Platform (Unix Socket or TCP Socket) positional arguments: message Message to send (if not provided, read from stdin) options: -h, --help show this help message and exit -s SOCKET, --socket SOCKET Unix socket path (default: {temp_dir}/astrbot.sock) -t TIMEOUT, --timeout TIMEOUT Timeout in seconds (default: 30.0) -j, --json Output raw JSON response --log Get recent console logs (instead of sending a message) --lines LINES Number of log lines to return (default: 100, max: 1000) --level LEVEL Filter logs by level (DEBUG/INFO/WARNING/ERROR/CRITICAL) --pattern PATTERN Filter logs by pattern (substring match) Examples: astr "你好" astr "/help" astr --socket /tmp/custom.sock "测试消息" echo "你好" | astr Connection: Automatically detects connection type from .cli_connection file. Falls back to default Unix Socket if file not found. 命令替代，功能已整合到 包中 --- astrbot-cli | 327 ---------------------------------------------------- 1 file changed, 327 deletions(-) delete mode 100644 astrbot-cli diff --git a/astrbot-cli b/astrbot-cli deleted file mode 100644 index c3e6741c1e..0000000000 --- a/astrbot-cli +++ /dev/null @@ -1,327 +0,0 @@ -#!/usr/bin/env python3 -""" -AstrBot CLI Tool - 跨平台Socket客户端 - -支持Unix Socket和TCP Socket连接 - -用法: - astrbot-cli "你好" - astrbot-cli "/help" - echo "你好" | astrbot-cli -""" - -import argparse -import io -import json -import os -import socket -import sys -import uuid -from typing import Optional - -# Windows UTF-8 输出支持 -if sys.platform == "win32": - # 设置stdout/stderr为UTF-8编码 - sys.stdout = io.TextIOWrapper(sys.stdout.buffer, encoding="utf-8", errors="replace") - sys.stderr = io.TextIOWrapper(sys.stderr.buffer, encoding="utf-8", errors="replace") - - -def get_data_path() -> str: - """获取数据目录路径,兼容容器和非容器环境""" - # 优先使用环境变量 - if root := os.environ.get("ASTRBOT_ROOT"): - return os.path.join(root, "data") - # 默认路径 - return os.path.join(os.getcwd(), "data") - - -def get_temp_path() -> str: - """获取临时目录路径,兼容容器和非容器环境""" - # 优先使用环境变量 - if root := os.environ.get("ASTRBOT_ROOT"): - return os.path.join(root, "data", "temp") - # 默认使用系统临时目录 - return "/tmp" - - -def load_auth_token() -> str: - """从密钥文件加载认证token - - Returns: - token字符串,如果文件不存在则返回空字符串 - """ - token_file = os.path.join(get_data_path(), ".cli_token") - try: - with open(token_file, encoding="utf-8") as f: - return f.read().strip() - except FileNotFoundError: - return "" - except Exception: - return "" - - -def load_connection_info(data_dir: str) -> Optional[dict]: - """加载连接信息 - - 从.cli_connection文件读取Socket连接信息 - - Args: - data_dir: 数据目录路径 - - Returns: - 连接信息字典，如果文件不存在则返回None - - Example: - Unix Socket: {"type": "unix", "path": "/tmp/astrbot.sock"} - TCP Socket: {"type": "tcp", "host": "127.0.0.1", "port": 12345} - """ - connection_file = os.path.join(data_dir, ".cli_connection") - try: - with open(connection_file, encoding="utf-8") as f: - connection_info = json.load(f) - return connection_info - except FileNotFoundError: - return None - except json.JSONDecodeError as e: - print( - f"[ERROR] Invalid JSON in connection file: {connection_file}", - file=sys.stderr, - ) - print(f"[ERROR] {e}", file=sys.stderr) - return None - except Exception as e: - print( - f"[ERROR] Failed to load connection info: {e}", - file=sys.stderr, - ) - return None - - -def connect_to_server(connection_info: dict, timeout: float = 30.0) -> socket.socket: - """连接到服务器 - - 根据连接信息类型选择Unix Socket或TCP Socket连接 - - Args: - connection_info: 连接信息字典 - timeout: 超时时间（秒） - - Returns: - socket连接对象 - - Raises: - ValueError: 无效的连接类型 - ConnectionError: 连接失败 - """ - socket_type = connection_info.get("type") - - if socket_type == "unix": - # Unix Socket连接 - socket_path = connection_info.get("path") - if not socket_path: - raise ValueError("Unix socket path is missing in connection info") - - try: - client_socket = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM) - client_socket.settimeout(timeout) - client_socket.connect(socket_path) - return client_socket - except FileNotFoundError: - raise ConnectionError( - f"Socket file not found: {socket_path}. Is AstrBot running?" - ) - except ConnectionRefusedError: - raise ConnectionError( - "Connection refused. Is AstrBot running in socket mode?" - ) - except Exception as e: - raise ConnectionError(f"Unix socket connection error: {e}") - - elif socket_type == "tcp": - # TCP Socket连接 - host = connection_info.get("host") - port = connection_info.get("port") - if not host or not port: - raise ValueError("TCP host or port is missing in connection info") - - try: - client_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM) - client_socket.settimeout(timeout) - client_socket.connect((host, port)) - return client_socket - except ConnectionRefusedError: - raise ConnectionError( - f"Connection refused to {host}:{port}. Is AstrBot running?" - ) - except socket.timeout: - raise ConnectionError(f"Connection timeout to {host}:{port}") - except Exception as e: - raise ConnectionError(f"TCP socket connection error: {e}") - - else: - raise ValueError( - f"Invalid socket type: {socket_type}. Expected 'unix' or 'tcp'" - ) - - -def send_message( - message: str, socket_path: str | None = None, timeout: float = 30.0 -) -> dict: - """发送消息到AstrBot并获取响应 - - 支持自动检测连接类型（Unix Socket或TCP Socket） - - Args: - message: 要发送的消息 - socket_path: Unix socket路径(仅用于向后兼容，优先使用.cli_connection) - timeout: 超时时间（秒） - - Returns: - 响应字典 - """ - # [ENTRY] send_message - data_dir = get_data_path() - - # 加载认证token - auth_token = load_auth_token() - - # 创建请求 - request = {"message": message, "request_id": str(uuid.uuid4())} - - # 如果token存在,添加到请求中 - if auth_token: - request["auth_token"] = auth_token - - # [PROCESS] 尝试加载连接信息 - connection_info = load_connection_info(data_dir) - - # 连接到服务器 - try: - if connection_info is not None: - # [PROCESS] 使用连接信息文件 - client_socket = connect_to_server(connection_info, timeout) - else: - # [PROCESS] 向后兼容：使用默认Unix Socket路径 - if socket_path is None: - socket_path = os.path.join(get_temp_path(), "astrbot.sock") - - fallback_info = {"type": "unix", "path": socket_path} - client_socket = connect_to_server(fallback_info, timeout) - - except (ValueError, ConnectionError) as e: - return {"status": "error", "error": str(e)} - except Exception as e: - return {"status": "error", "error": f"Connection error: {e}"} - - try: - # [PROCESS] 发送请求 - request_data = json.dumps(request, ensure_ascii=False).encode("utf-8") - client_socket.sendall(request_data) - - # [PROCESS] 接收响应（循环接收所有数据，支持大响应如base64图片） - response_data = b"" - while True: - chunk = client_socket.recv(4096) - if not chunk: - break - response_data += chunk - # 尝试解析JSON，如果成功说明接收完整 - try: - response = json.loads(response_data.decode("utf-8")) - # [EXIT] send_message success - return response - except json.JSONDecodeError: - # JSON不完整，继续接收 - continue - - # 如果循环结束仍未成功解析，尝试最后一次 - response = json.loads(response_data.decode("utf-8")) - # [EXIT] send_message success - return response - - except TimeoutError: - # [ERROR] Request timeout - return {"status": "error", "error": "Request timeout"} - except Exception as e: - # [ERROR] Communication error - return {"status": "error", "error": f"Communication error: {e}"} - finally: - client_socket.close() - - -def main(): - """主函数""" - parser = argparse.ArgumentParser( - description="AstrBot CLI Tool - Send messages to AstrBot (Unix Socket or TCP Socket)", - formatter_class=argparse.RawDescriptionHelpFormatter, - epilog=""" -Examples: - astrbot-cli "你好" - astrbot-cli "/help" - astrbot-cli --socket /tmp/custom.sock "测试消息" - echo "你好" | astrbot-cli - -Connection: - Automatically detects connection type from .cli_connection file. - Falls back to default Unix Socket if file not found. - """, - ) - - parser.add_argument( - "message", nargs="?", help="Message to send (if not provided, read from stdin)" - ) - - parser.add_argument( - "-s", - "--socket", - default=None, - help="Unix socket path (default: {temp_dir}/astrbot.sock)", - ) - - parser.add_argument( - "-t", - "--timeout", - type=float, - default=30.0, - help="Timeout in seconds (default: 30.0)", - ) - - parser.add_argument( - "-j", "--json", action="store_true", help="Output raw JSON response" - ) - - args = parser.parse_args() - - # 获取消息内容 - if args.message: - message = args.message - elif not sys.stdin.isatty(): - # 从stdin读取 - message = sys.stdin.read().strip() - else: - parser.print_help() - sys.exit(1) - - if not message: - print("Error: Empty message", file=sys.stderr) - sys.exit(1) - - # 发送消息 - response = send_message(message, args.socket, args.timeout) - - # 输出响应 - if args.json: - # 输出原始JSON - print(json.dumps(response, ensure_ascii=False, indent=2)) - else: - # 格式化输出 - if response.get("status") == "success": - print(response.get("response", "")) - else: - error = response.get("error", "Unknown error") - print(f"Error: {error}", file=sys.stderr) - sys.exit(1) - - -if __name__ == "__main__": - main() From c32114b8c0608d26dd897e5893a970d18bf2bef9 Mon Sep 17 00:00:00 2001 From: YukiRa1n <167516635+YukiRa1n@users.noreply.github.com> Date: Thu, 5 Feb 2026 21:20:47 +0800 Subject: [PATCH 12/39] =?UTF-8?q?docs:=20=E6=94=B9=E8=BF=9B=20usage:=20ast?= =?UTF-8?q?r=20[-h]=20[-s=20SOCKET]=20[-t=20TIMEOUT]=20[-j]=20[--log]=20[-?= =?UTF-8?q?-lines=20LINES]=20=20=20=20=20=20=20=20=20=20=20=20=20[--level?= =?UTF-8?q?=20LEVEL]=20[--pattern=20PATTERN]=20=20=20=20=20=20=20=20=20=20?= =?UTF-8?q?=20=20=20[message]?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit AstrBot CLI Client - 与 CLI Platform 通信的客户端工具 positional arguments: message Message to send (if not provided, read from stdin) options: -h, --help show this help message and exit -s SOCKET, --socket SOCKET Unix socket path (default: {temp_dir}/astrbot.sock) -t TIMEOUT, --timeout TIMEOUT Timeout in seconds (default: 30.0) -j, --json Output raw JSON response --log Get recent console logs (instead of sending a message) --lines LINES Number of log lines to return (default: 100, max: 1000) --level LEVEL Filter logs by level (DEBUG/INFO/WARNING/ERROR/CRITICAL) --pattern PATTERN Filter logs by pattern (substring match) 使用示例: 发送消息: astr "你好" # 发送消息给 AstrBot astr "/help" # 查看内置帮助 echo "你好" | astr # 从标准输入读取 获取日志: astr --log # 获取最近 100 行日志 astr --log --lines 50 # 获取最近 50 行 astr --log --level ERROR # 只显示 ERROR 级别 astr --log --pattern "CLI" # 只显示包含 "CLI" 的日志 astr --log --json # 以 JSON 格式输出日志 高级选项: astr -j "测试" # 输出原始 JSON 响应 astr -t 60 "长时间任务" # 设置超时时间为 60 秒 连接说明: - 自动从 data/.cli_connection 文件检测连接类型（Unix Socket 或 TCP） - Token 自动从 data/.cli_token 文件读取 - 必须在 AstrBot 根目录下运行，或设置 ASTRBOT_ROOT 环境变量 输出 - 添加中文说明 - 补充详细使用示例（发送消息、获取日志、高级选项） - 添加连接说明 --- astrbot/cli/client/__main__.py | 33 +++++++++++++++++++++++---------- 1 file changed, 23 insertions(+), 10 deletions(-) diff --git a/astrbot/cli/client/__main__.py b/astrbot/cli/client/__main__.py index 4f269c787b..b5aba2bf17 100644 --- a/astrbot/cli/client/__main__.py +++ b/astrbot/cli/client/__main__.py @@ -353,18 +353,31 @@ def get_logs( def main() -> None: """主函数""" parser = argparse.ArgumentParser( - description="AstrBot CLI Client - Send messages to AstrBot CLI Platform (Unix Socket or TCP Socket)", + description="AstrBot CLI Client - 与 CLI Platform 通信的客户端工具", formatter_class=argparse.RawDescriptionHelpFormatter, epilog=""" -Examples: - astr "你好" - astr "/help" - astr --socket /tmp/custom.sock "测试消息" - echo "你好" | astr - -Connection: - Automatically detects connection type from .cli_connection file. - Falls back to default Unix Socket if file not found. +使用示例: + + 发送消息: + astr "你好" # 发送消息给 AstrBot + astr "/help" # 查看内置帮助 + echo "你好" | astr # 从标准输入读取 + + 获取日志: + astr --log # 获取最近 100 行日志 + astr --log --lines 50 # 获取最近 50 行 + astr --log --level ERROR # 只显示 ERROR 级别 + astr --log --pattern "CLI" # 只显示包含 "CLI" 的日志 + astr --log --json # 以 JSON 格式输出日志 + + 高级选项: + astr -j "测试" # 输出原始 JSON 响应 + astr -t 60 "长时间任务" # 设置超时时间为 60 秒 + +连接说明: + - 自动从 data/.cli_connection 文件检测连接类型（Unix Socket 或 TCP） + - Token 自动从 data/.cli_token 文件读取 + - 必须在 AstrBot 根目录下运行，或设置 ASTRBOT_ROOT 环境变量 """, ) From a36feb0c2e760b473e09af37a6af6f4a75192e5d Mon Sep 17 00:00:00 2001 From: YukiRa1n <167516635+YukiRa1n@users.noreply.github.com> Date: Thu, 5 Feb 2026 21:25:50 +0800 Subject: [PATCH 13/39] =?UTF-8?q?docs:=20=E4=BF=AE=E6=AD=A3=20help=20?= =?UTF-8?q?=E7=A4=BA=E4=BE=8B=EF=BC=8C=E7=A7=BB=E9=99=A4=E5=91=BD=E4=BB=A4?= =?UTF-8?q?=E5=89=8D=E7=9A=84=20/?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - / 不是 AstrBot 的命令前缀 - help 等内置命令不需要 / 前缀 - 添加内置命令使用示例说明 - 说明带 / 的消息会发给 LLM 处理 --- astrbot/cli/client/__main__.py | 11 +++++++++-- 1 file changed, 9 insertions(+), 2 deletions(-) diff --git a/astrbot/cli/client/__main__.py b/astrbot/cli/client/__main__.py index b5aba2bf17..2482153c26 100644 --- a/astrbot/cli/client/__main__.py +++ b/astrbot/cli/client/__main__.py @@ -359,8 +359,8 @@ def main() -> None: 使用示例: 发送消息: - astr "你好" # 发送消息给 AstrBot - astr "/help" # 查看内置帮助 + astr 你好 # 发送消息给 AstrBot + astr help # 查看内置命令帮助 echo "你好" | astr # 从标准输入读取 获取日志: @@ -370,6 +370,13 @@ def main() -> None: astr --log --pattern "CLI" # 只显示包含 "CLI" 的日志 astr --log --json # 以 JSON 格式输出日志 + 内置命令: + astr help # 查看所有命令 + astr plugin ls # 列出已安装插件 + astr plugin on # 启用插件 + astr new # 创建新对话 + astr /自定义消息 # 带 / 的消息发给 LLM 处理 + 高级选项: astr -j "测试" # 输出原始 JSON 响应 astr -t 60 "长时间任务" # 设置超时时间为 60 秒 From 2b34879a78745adcc0d204e2dbebfd0ffc1b92c0 Mon Sep 17 00:00:00 2001 From: YukiRa1n <167516635+YukiRa1n@users.noreply.github.com> Date: Thu, 5 Feb 2026 21:49:16 +0800 Subject: [PATCH 14/39] =?UTF-8?q?fix:=20=E6=94=AF=E6=8C=81=E4=BB=A5=20/=20?= =?UTF-8?q?=E5=BC=80=E5=A4=B4=E7=9A=84=E5=91=BD=E4=BB=A4=E5=8F=82=E6=95=B0?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit 使用 argparse.REMAINDER 模式捕获所有剩余参数， 允许 /plugin ls 这类命令正常工作。 --- astrbot/cli/client/__main__.py | 7 +++++-- 1 file changed, 5 insertions(+), 2 deletions(-) diff --git a/astrbot/cli/client/__main__.py b/astrbot/cli/client/__main__.py index 2482153c26..1a65e135ef 100644 --- a/astrbot/cli/client/__main__.py +++ b/astrbot/cli/client/__main__.py @@ -389,7 +389,9 @@ def main() -> None: ) parser.add_argument( - "message", nargs="?", help="Message to send (if not provided, read from stdin)" + "message", + nargs=argparse.REMAINDER, + help="Message to send (if not provided, read from stdin)", ) parser.add_argument( @@ -445,7 +447,8 @@ def main() -> None: # 处理消息发送 # 获取消息内容 if args.message: - message = args.message + # REMAINDER 模式下 args.message 是列表，用空格连接 + message = " ".join(args.message) elif not sys.stdin.isatty(): # 从stdin读取 message = sys.stdin.read().strip() From 7bc244bafa9f8d51d34b76ed7c58e97cc11913cb Mon Sep 17 00:00:00 2001 From: YukiRa1n <167516635+YukiRa1n@users.noreply.github.com> Date: Thu, 5 Feb 2026 21:53:26 +0800 Subject: [PATCH 15/39] =?UTF-8?q?fix:=20=E4=BF=AE=E5=A4=8D=20UTF-8=20?= =?UTF-8?q?=E5=A4=9A=E5=AD=97=E8=8A=82=E5=AD=97=E7=AC=A6=E8=A7=A3=E7=A0=81?= =?UTF-8?q?=E9=97=AE=E9=A2=98?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit 在接收 Socket 数据时，如果多字节字符被截断在缓冲区边界会导致解码失败。 使用 errors="replace" 参数来处理截断的 UTF-8 字符。 --- astrbot/cli/client/__main__.py | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/astrbot/cli/client/__main__.py b/astrbot/cli/client/__main__.py index 1a65e135ef..bb340c7307 100644 --- a/astrbot/cli/client/__main__.py +++ b/astrbot/cli/client/__main__.py @@ -248,14 +248,14 @@ def send_message( response_data += chunk # 尝试解析JSON，如果成功说明接收完整 try: - response = json.loads(response_data.decode("utf-8")) + response = json.loads(response_data.decode("utf-8", errors="replace")) return response except json.JSONDecodeError: # JSON不完整，继续接收 continue # 如果循环结束仍未成功解析，尝试最后一次 - response = json.loads(response_data.decode("utf-8")) + response = json.loads(response_data.decode("utf-8", errors="replace")) return response except TimeoutError: @@ -334,12 +334,12 @@ def get_logs( break response_data += chunk try: - response = json.loads(response_data.decode("utf-8")) + response = json.loads(response_data.decode("utf-8", errors="replace")) return response except json.JSONDecodeError: continue - response = json.loads(response_data.decode("utf-8")) + response = json.loads(response_data.decode("utf-8", errors="replace")) return response except TimeoutError: From ef179f936227241d9d7cf642bcff276cf373f193 Mon Sep 17 00:00:00 2001 From: YukiRa1n <167516635+YukiRa1n@users.noreply.github.com> Date: Thu, 5 Feb 2026 22:11:16 +0800 Subject: [PATCH 16/39] =?UTF-8?q?feat:=20=E6=94=B9=E8=BF=9B=20CLI=20?= =?UTF-8?q?=E8=BE=93=E5=87=BA=E6=A0=BC=E5=BC=8F=E5=92=8C=E6=B7=BB=E5=8A=A0?= =?UTF-8?q?=E6=97=A5=E5=BF=97=E6=9F=A5=E8=AF=A2=E5=8A=9F=E8=83=BD?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - 添加 format_response() 函数处理分段回复和图片占位符 - 图片显示为 [图片] 或 [N张图片] 占位符 - 更新 --help 说明，添加输出说明部分 - 修复 socket_handler.py 中 action 变量未定义的问题 - 修复 _get_logs() 方法返回格式问题 --- astrbot/cli/client/__main__.py | 47 ++++++++++++++++++- .../sources/cli/handlers/socket_handler.py | 19 +++++--- 2 files changed, 59 insertions(+), 7 deletions(-) diff --git a/astrbot/cli/client/__main__.py b/astrbot/cli/client/__main__.py index bb340c7307..4353eaa01b 100644 --- a/astrbot/cli/client/__main__.py +++ b/astrbot/cli/client/__main__.py @@ -350,6 +350,43 @@ def get_logs( client_socket.close() +def format_response(response: dict) -> str: + """格式化响应输出 + + 处理： + 1. 分段回复（每行一句） + 2. 图片占位符 + + Args: + response: 响应字典 + + Returns: + 格式化后的字符串 + """ + if response.get("status") != "success": + return "" + + # 获取文本响应 + text = response.get("response", "") + + # 获取图片数量 + images = response.get("images", []) + image_count = len(images) + + # 处理分段：按换行符分割，然后每行单独输出 + lines = text.split("\n") + + # 如果有图片，在末尾添加图片占位符 + if image_count > 0: + if image_count == 1: + lines.append("[图片]") + else: + lines.append(f"[{image_count}张图片]") + + # 用换行符连接所有行 + return "\n".join(lines) + + def main() -> None: """主函数""" parser = argparse.ArgumentParser( @@ -385,6 +422,12 @@ def main() -> None: - 自动从 data/.cli_connection 文件检测连接类型（Unix Socket 或 TCP） - Token 自动从 data/.cli_token 文件读取 - 必须在 AstrBot 根目录下运行，或设置 ASTRBOT_ROOT 环境变量 + +输出说明: + - 默认模式下，图片以 [图片] 占位符显示，不返回实际图片内容 + - 分段回复会自动分行显示 + - 如需完整信息（包括图片 URL/base64），请使用 -j 参数输出 JSON + - 如需查看详细日志，请使用 --log 参数 """, ) @@ -469,7 +512,9 @@ def main() -> None: else: # 格式化输出 if response.get("status") == "success": - print(response.get("response", "")) + # 使用格式化函数处理响应 + formatted = format_response(response) + print(formatted) else: error = response.get("error", "Unknown error") print(f"Error: {error}", file=sys.stderr) diff --git a/astrbot/core/platform/sources/cli/handlers/socket_handler.py b/astrbot/core/platform/sources/cli/handlers/socket_handler.py index 2c60348def..ecbe499e11 100644 --- a/astrbot/core/platform/sources/cli/handlers/socket_handler.py +++ b/astrbot/core/platform/sources/cli/handlers/socket_handler.py @@ -78,6 +78,7 @@ async def handle(self, client_socket) -> None: request_id = request.get("request_id", str(uuid.uuid4())) auth_token = request.get("auth_token", "") + action = request.get("action", "") # Token验证（所有请求都需要token） if not self.token_manager.validate(auth_token): @@ -212,9 +213,12 @@ async def _get_logs(self, request: dict, request_id: str) -> str: log_path = os.path.join(self.data_path, "logs", "astrbot.log") if not os.path.exists(log_path): - return ResponseBuilder.build_success( - "", request_id, message="Log file not found" - ) + return json.dumps({ + "status": "success", + "response": "", + "message": "Log file not found", + "request_id": request_id, + }, ensure_ascii=False) # 读取日志文件（从末尾开始） logs = [] @@ -253,9 +257,12 @@ async def _get_logs(self, request: dict, request_id: str) -> str: # 构建响应 log_text = "\n".join(logs) - return ResponseBuilder.build_success( - log_text, request_id, message=f"Retrieved {len(logs)} log lines" - ) + return json.dumps({ + "status": "success", + "response": log_text, + "message": f"Retrieved {len(logs)} log lines", + "request_id": request_id, + }, ensure_ascii=False) except Exception as e: logger.exception("Error getting logs") From 94cba4b2b0f0984f2be368669b8f2c294765d91c Mon Sep 17 00:00:00 2001 From: YukiRa1n <167516635+YukiRa1n@users.noreply.github.com> Date: Thu, 5 Feb 2026 22:21:49 +0800 Subject: [PATCH 17/39] =?UTF-8?q?chore:=20=E6=94=B9=E8=BF=9B=E6=97=A5?= =?UTF-8?q?=E5=BF=97=E6=9F=A5=E8=AF=A2=E9=94=99=E8=AF=AF=E6=8F=90=E7=A4=BA?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit 当日志文件不存在时，返回中文提示信息， 说明需要在配置中启用 log_file_enable。 --- astrbot/core/platform/sources/cli/handlers/socket_handler.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/astrbot/core/platform/sources/cli/handlers/socket_handler.py b/astrbot/core/platform/sources/cli/handlers/socket_handler.py index ecbe499e11..61141fb1f5 100644 --- a/astrbot/core/platform/sources/cli/handlers/socket_handler.py +++ b/astrbot/core/platform/sources/cli/handlers/socket_handler.py @@ -216,7 +216,7 @@ async def _get_logs(self, request: dict, request_id: str) -> str: return json.dumps({ "status": "success", "response": "", - "message": "Log file not found", + "message": "日志文件未找到。请在配置中启用 log_file_enable 来记录日志到文件。", "request_id": request_id, }, ensure_ascii=False) From 0e52245ea0b97939d5c0556d9ef94f9c0c2f1f1a Mon Sep 17 00:00:00 2001 From: YukiRa1n <167516635+YukiRa1n@users.noreply.github.com> Date: Thu, 5 Feb 2026 22:27:26 +0800 Subject: [PATCH 18/39] =?UTF-8?q?style:=20ruff=20format=20=E5=92=8C=20lint?= =?UTF-8?q?=20=E6=A3=80=E6=9F=A5=E9=80=9A=E8=BF=87?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - 添加 noqa 注释抑制必要的警告 - 格式化代码符合 ruff 规范 --- astrbot/cli/client/__main__.py | 23 +++++------ .../sources/cli/handlers/socket_handler.py | 38 ++++++++++--------- 2 files changed, 33 insertions(+), 28 deletions(-) diff --git a/astrbot/cli/client/__main__.py b/astrbot/cli/client/__main__.py index 4353eaa01b..5f512b45c4 100644 --- a/astrbot/cli/client/__main__.py +++ b/astrbot/cli/client/__main__.py @@ -24,14 +24,13 @@ if isinstance(handler, logging.StreamHandler): root.removeHandler(handler) -import argparse -import io -import json -import os -import socket -import sys -import uuid -from typing import Optional +import argparse # noqa: E402 +import io # noqa: E402 +import json # noqa: E402 +import os # noqa: E402 +import socket # noqa: E402 +import sys # noqa: E402 +import uuid # noqa: E402 # 仅使用标准库导入，不导入astrbot框架 # Windows UTF-8 输出支持 @@ -82,7 +81,7 @@ def load_auth_token() -> str: return "" -def load_connection_info(data_dir: str) -> Optional[dict]: +def load_connection_info(data_dir: str) -> dict | None: """加载连接信息 从.cli_connection文件读取Socket连接信息 @@ -175,7 +174,7 @@ def connect_to_server(connection_info: dict, timeout: float = 30.0) -> socket.so raise ConnectionError( f"Connection refused to {host}:{port}. Is AstrBot running?" ) - except socket.timeout: + except TimeoutError: raise ConnectionError(f"Connection timeout to {host}:{port}") except Exception as e: raise ConnectionError(f"TCP socket connection error: {e}") @@ -485,7 +484,9 @@ def main() -> None: # 处理日志请求 if args.log: - response = get_logs(args.socket, args.timeout, args.lines, args.level, args.pattern) + response = get_logs( + args.socket, args.timeout, args.lines, args.level, args.pattern + ) else: # 处理消息发送 # 获取消息内容 diff --git a/astrbot/core/platform/sources/cli/handlers/socket_handler.py b/astrbot/core/platform/sources/cli/handlers/socket_handler.py index 61141fb1f5..74c4e75179 100644 --- a/astrbot/core/platform/sources/cli/handlers/socket_handler.py +++ b/astrbot/core/platform/sources/cli/handlers/socket_handler.py @@ -212,18 +212,21 @@ async def _get_logs(self, request: dict, request_id: str) -> str: # 日志文件路径 log_path = os.path.join(self.data_path, "logs", "astrbot.log") - if not os.path.exists(log_path): - return json.dumps({ - "status": "success", - "response": "", - "message": "日志文件未找到。请在配置中启用 log_file_enable 来记录日志到文件。", - "request_id": request_id, - }, ensure_ascii=False) + if not os.path.exists(log_path): # noqa: ASYNC240 + return json.dumps( + { + "status": "success", + "response": "", + "message": "日志文件未找到。请在配置中启用 log_file_enable 来记录日志到文件。", + "request_id": request_id, + }, + ensure_ascii=False, + ) # 读取日志文件（从末尾开始） logs = [] try: - with open(log_path, "r", encoding="utf-8", errors="ignore") as f: + with open(log_path, encoding="utf-8", errors="ignore") as f: # 读取所有行 all_lines = f.readlines() @@ -257,18 +260,19 @@ async def _get_logs(self, request: dict, request_id: str) -> str: # 构建响应 log_text = "\n".join(logs) - return json.dumps({ - "status": "success", - "response": log_text, - "message": f"Retrieved {len(logs)} log lines", - "request_id": request_id, - }, ensure_ascii=False) + return json.dumps( + { + "status": "success", + "response": log_text, + "message": f"Retrieved {len(logs)} log lines", + "request_id": request_id, + }, + ensure_ascii=False, + ) except Exception as e: logger.exception("Error getting logs") - return ResponseBuilder.build_error( - f"Error getting logs: {e}", request_id - ) + return ResponseBuilder.build_error(f"Error getting logs: {e}", request_id) class SocketModeHandler(IHandler): From 669c931b9e0d279c54072df3ae813c3676a4d936 Mon Sep 17 00:00:00 2001 From: YukiRa1n <167516635+YukiRa1n@users.noreply.github.com> Date: Thu, 5 Feb 2026 22:35:27 +0800 Subject: [PATCH 19/39] =?UTF-8?q?fix:=20=E5=85=BC=E5=AE=B9=20Git=20Bash=20?= =?UTF-8?q?=E7=9A=84=E8=B7=AF=E5=BE=84=E8=BD=AC=E6=8D=A2=E9=97=AE=E9=A2=98?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Git Bash (MSYS2) 会把 /plugin ls 转换为 C:/Program Files/Git/plugin ls 添加 fix_git_bash_path() 函数检测并还原原始命令 --- astrbot/cli/client/__main__.py | 32 ++++++++++++++++++++++++++++++++ 1 file changed, 32 insertions(+) diff --git a/astrbot/cli/client/__main__.py b/astrbot/cli/client/__main__.py index 5f512b45c4..f525d6ed80 100644 --- a/astrbot/cli/client/__main__.py +++ b/astrbot/cli/client/__main__.py @@ -28,6 +28,7 @@ import io # noqa: E402 import json # noqa: E402 import os # noqa: E402 +import re # noqa: E402 import socket # noqa: E402 import sys # noqa: E402 import uuid # noqa: E402 @@ -386,6 +387,35 @@ def format_response(response: dict) -> str: return "\n".join(lines) +def fix_git_bash_path(message: str) -> str: + """修复 Git Bash 路径转换问题 + + Git Bash (MSYS2) 会把 /plugin ls 转换为 C:/Program Files/Git/plugin ls + 检测并还原原始命令 + + Args: + message: 被转换后的消息 + + Returns: + 修复后的消息 + """ + # 检测是否是 Git Bash 转换的路径 + # 模式: :/Program Files/Git/ + pattern = r"[A-Z]:/(Program Files/Git|msys[0-9]+/[^/]+)/([^/]+)" + match = re.match(pattern, message) + + if match: + # 提取原始命令 + command = match.group(2) + # 获取剩余部分 + rest = message[match.end():].lstrip() + if rest: + return f"/{command} {rest}" + return f"/{command}" + + return message + + def main() -> None: """主函数""" parser = argparse.ArgumentParser( @@ -493,6 +523,8 @@ def main() -> None: if args.message: # REMAINDER 模式下 args.message 是列表，用空格连接 message = " ".join(args.message) + # 修复 Git Bash 路径转换问题 + message = fix_git_bash_path(message) elif not sys.stdin.isatty(): # 从stdin读取 message = sys.stdin.read().strip() From e8a7638b0389694fb0cb698a8e976a97a7e15e76 Mon Sep 17 00:00:00 2001 From: YukiRa1n <167516635+YukiRa1n@users.noreply.github.com> Date: Thu, 5 Feb 2026 23:38:41 +0800 Subject: [PATCH 20/39] =?UTF-8?q?fix:=20CLI=20=E5=AE=A2=E6=88=B7=E7=AB=AF?= =?UTF-8?q?=E6=94=AF=E6=8C=81=E5=85=A8=E5=B1=80=E8=B0=83=E7=94=A8?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- astrbot/cli/client/__main__.py | 25 ++++++++++++++++++------- 1 file changed, 18 insertions(+), 7 deletions(-) diff --git a/astrbot/cli/client/__main__.py b/astrbot/cli/client/__main__.py index f525d6ed80..73a754fc90 100644 --- a/astrbot/cli/client/__main__.py +++ b/astrbot/cli/client/__main__.py @@ -42,19 +42,30 @@ def get_data_path() -> str: - """获取数据目录路径（复制自 astrbot.core.utils.astrbot_path.get_astrbot_data_path） + """获取数据目录路径 优先级： 1. 环境变量 ASTRBOT_ROOT - 2. 当前工作目录 + 2. 源码安装目录（通过 __file__ 获取） + 3. 当前工作目录 """ - # 获取根目录 + # 优先使用环境变量 if root := os.environ.get("ASTRBOT_ROOT"): - root_path = os.path.realpath(root) - else: - root_path = os.path.realpath(os.getcwd()) + return os.path.join(root, "data") + + # 获取源码安装目录（__main__.py 在 astrbot/cli/client/） + # 向上 3 级到达根目录 + source_root = os.path.realpath( + os.path.join(os.path.dirname(os.path.abspath(__file__)), "../../..") + ) + data_dir = os.path.join(source_root, "data") + + # 如果源码目录下存在 data 目录，使用它 + if os.path.exists(data_dir): + return data_dir - return os.path.join(root_path, "data") + # 回退到当前工作目录 + return os.path.join(os.path.realpath(os.getcwd()), "data") def get_temp_path() -> str: From e36f972aadc9661ec93f440f1f8c790f2ddbd7c2 Mon Sep 17 00:00:00 2001 From: YukiRa1n <167516635+YukiRa1n@users.noreply.github.com> Date: Fri, 6 Feb 2026 16:40:54 +0800 Subject: [PATCH 21/39] =?UTF-8?q?refactor(cli):=20=E9=87=87=E7=BA=B3PR=20r?= =?UTF-8?q?eview=EF=BC=8Cargparse=E6=94=B9=E4=B8=BAclick=20+=20=E4=BF=AE?= =?UTF-8?q?=E5=A4=8Dasyncio=E5=BC=83=E7=94=A8API?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit 1. astrbot/cli/client/__main__.py: argparse → click (LIghtJUNction review) - 子命令结构: astr send / astr log - DefaultToSend兼容: astr 你好 等价于 astr send 你好 - RawEpilogGroup保留帮助文本原始格式 - 支持shell tab补全(Bash/Zsh/Fish) 2. tcp_socket_server.py: get_event_loop() → get_running_loop() (sourcery-ai review) - Python 3.10+弃用get_event_loop()，async函数中应使用get_running_loop() --- astrbot/cli/client/__main__.py | 247 +++++++++--------- .../platform/sources/cli/tcp_socket_server.py | 2 +- 2 files changed, 128 insertions(+), 121 deletions(-) diff --git a/astrbot/cli/client/__main__.py b/astrbot/cli/client/__main__.py index 73a754fc90..82c5a224ee 100644 --- a/astrbot/cli/client/__main__.py +++ b/astrbot/cli/client/__main__.py @@ -24,7 +24,6 @@ if isinstance(handler, logging.StreamHandler): root.removeHandler(handler) -import argparse # noqa: E402 import io # noqa: E402 import json # noqa: E402 import os # noqa: E402 @@ -33,6 +32,8 @@ import sys # noqa: E402 import uuid # noqa: E402 +import click # noqa: E402 + # 仅使用标准库导入，不导入astrbot框架 # Windows UTF-8 输出支持 if sys.platform == "win32": @@ -427,142 +428,148 @@ def fix_git_bash_path(message: str) -> str: return message -def main() -> None: - """主函数""" - parser = argparse.ArgumentParser( - description="AstrBot CLI Client - 与 CLI Platform 通信的客户端工具", - formatter_class=argparse.RawDescriptionHelpFormatter, - epilog=""" -使用示例: - +EPILOG = """使用示例: 发送消息: - astr 你好 # 发送消息给 AstrBot - astr help # 查看内置命令帮助 - echo "你好" | astr # 从标准输入读取 + astr 你好 直接发送（兼容旧用法） + astr send 你好 发送消息给 AstrBot + astr send /help 查看内置命令帮助 + echo "你好" | astr send 从标准输入读取 获取日志: - astr --log # 获取最近 100 行日志 - astr --log --lines 50 # 获取最近 50 行 - astr --log --level ERROR # 只显示 ERROR 级别 - astr --log --pattern "CLI" # 只显示包含 "CLI" 的日志 - astr --log --json # 以 JSON 格式输出日志 - - 内置命令: - astr help # 查看所有命令 - astr plugin ls # 列出已安装插件 - astr plugin on # 启用插件 - astr new # 创建新对话 - astr /自定义消息 # 带 / 的消息发给 LLM 处理 + astr log 获取最近 100 行日志 + astr log --lines 50 获取最近 50 行 + astr log --level ERROR 只显示 ERROR 级别 + astr log --pattern "CLI" 只显示包含 "CLI" 的日志 + astr log -j 以 JSON 格式输出日志 高级选项: - astr -j "测试" # 输出原始 JSON 响应 - astr -t 60 "长时间任务" # 设置超时时间为 60 秒 + astr send -j "测试" 输出原始 JSON 响应 + astr send -t 60 "长时间任务" 设置超时时间为 60 秒 连接说明: - - 自动从 data/.cli_connection 文件检测连接类型（Unix Socket 或 TCP） - - Token 自动从 data/.cli_token 文件读取 - - 必须在 AstrBot 根目录下运行，或设置 ASTRBOT_ROOT 环境变量 - -输出说明: - - 默认模式下，图片以 [图片] 占位符显示，不返回实际图片内容 - - 分段回复会自动分行显示 - - 如需完整信息（包括图片 URL/base64），请使用 -j 参数输出 JSON - - 如需查看详细日志，请使用 --log 参数 - """, - ) - - parser.add_argument( - "message", - nargs=argparse.REMAINDER, - help="Message to send (if not provided, read from stdin)", - ) - - parser.add_argument( - "-s", - "--socket", - default=None, - help="Unix socket path (default: {temp_dir}/astrbot.sock)", - ) - - parser.add_argument( - "-t", - "--timeout", - type=float, - default=30.0, - help="Timeout in seconds (default: 30.0)", - ) - - parser.add_argument( - "-j", "--json", action="store_true", help="Output raw JSON response" - ) - - parser.add_argument( - "--log", - action="store_true", - help="Get recent console logs (instead of sending a message)", - ) - - parser.add_argument( - "--lines", - type=int, - default=100, - help="Number of log lines to return (default: 100, max: 1000)", - ) - - parser.add_argument( - "--level", - default="", - help="Filter logs by level (DEBUG/INFO/WARNING/ERROR/CRITICAL)", - ) - - parser.add_argument( - "--pattern", - default="", - help="Filter logs by pattern (substring match)", - ) + 自动从 data/.cli_connection 检测连接类型（Unix Socket 或 TCP） + Token 自动从 data/.cli_token 读取 + 需在 AstrBot 根目录下运行，或设置 ASTRBOT_ROOT 环境变量 +""" - args = parser.parse_args() - # 处理日志请求 - if args.log: - response = get_logs( - args.socket, args.timeout, args.lines, args.level, args.pattern - ) - else: - # 处理消息发送 - # 获取消息内容 - if args.message: - # REMAINDER 模式下 args.message 是列表，用空格连接 - message = " ".join(args.message) - # 修复 Git Bash 路径转换问题 - message = fix_git_bash_path(message) - elif not sys.stdin.isatty(): - # 从stdin读取 +class RawEpilogGroup(click.Group): + """保留 epilog 原始格式的 Group，同时支持默认子命令路由""" + + def format_epilog(self, ctx: click.Context, formatter: click.HelpFormatter) -> None: + if self.epilog: + formatter.write("\n") + for line in self.epilog.split("\n"): + formatter.write(line + "\n") + + def parse_args(self, ctx: click.Context, args: list[str]) -> list[str]: + # 兼容旧用法: astr 你好 等价于 astr send 你好 + if args and args[0] not in self.commands and not args[0].startswith("-"): + args = ["send"] + args + return super().parse_args(ctx, args) + + +@click.group( + cls=RawEpilogGroup, + invoke_without_command=True, + epilog=EPILOG, +) +@click.pass_context +def main(ctx: click.Context) -> None: + """AstrBot CLI Client""" + if ctx.invoked_subcommand is None: + # 无子命令时，检查 stdin 是否有管道输入 + if not sys.stdin.isatty(): message = sys.stdin.read().strip() - else: - parser.print_help() - sys.exit(1) - - if not message: - print("Error: Empty message", file=sys.stderr) - sys.exit(1) + if message: + _do_send(message, None, 30.0, False) + return + click.echo(ctx.get_help()) + + +@main.command(help="发送消息给 AstrBot") +@click.argument("message", nargs=-1) +@click.option("-s", "--socket", "socket_path", default=None, help="Unix socket 路径") +@click.option("-t", "--timeout", default=30.0, type=float, help="超时时间（秒）") +@click.option("-j", "--json", "use_json", is_flag=True, help="输出原始 JSON 响应") +def send( + message: tuple[str, ...], socket_path: str | None, timeout: float, use_json: bool +) -> None: + """发送消息给 AstrBot + + \b + 示例: + astr send 你好 + astr send /help + astr send plugin ls + echo "你好" | astr send + """ + if message: + msg = " ".join(message) + msg = fix_git_bash_path(msg) + elif not sys.stdin.isatty(): + msg = sys.stdin.read().strip() + else: + click.echo("Error: 请提供消息内容", err=True) + raise SystemExit(1) + + if not msg: + click.echo("Error: 消息内容为空", err=True) + raise SystemExit(1) + + _do_send(msg, socket_path, timeout, use_json) + + +def _do_send(msg: str, socket_path: str | None, timeout: float, use_json: bool) -> None: + """执行消息发送并输出结果""" + response = send_message(msg, socket_path, timeout) + _output_response(response, use_json) + + +@main.command(help="获取 AstrBot 日志") +@click.option( + "--lines", default=100, type=int, help="返回的日志行数（默认 100，最大 1000）" +) +@click.option( + "--level", default="", help="按级别过滤 (DEBUG/INFO/WARNING/ERROR/CRITICAL)" +) +@click.option("--pattern", default="", help="按模式过滤（子串匹配）") +@click.option("-s", "--socket", "socket_path", default=None, help="Unix socket 路径") +@click.option("-t", "--timeout", default=30.0, type=float, help="超时时间（秒）") +@click.option("-j", "--json", "use_json", is_flag=True, help="输出原始 JSON 响应") +def log( + lines: int, + level: str, + pattern: str, + socket_path: str | None, + timeout: float, + use_json: bool, +) -> None: + """获取 AstrBot 日志 + + \b + 示例: + astr log + astr log --lines 50 + astr log --level ERROR + astr log --pattern "plugin" + """ + response = get_logs(socket_path, timeout, lines, level, pattern) + _output_response(response, use_json) - response = send_message(message, args.socket, args.timeout) - # 输出响应 - if args.json: - # 输出原始JSON - print(json.dumps(response, ensure_ascii=False, indent=2)) +def _output_response(response: dict, use_json: bool) -> None: + """统一输出响应""" + if use_json: + click.echo(json.dumps(response, ensure_ascii=False, indent=2)) else: - # 格式化输出 if response.get("status") == "success": - # 使用格式化函数处理响应 formatted = format_response(response) - print(formatted) + click.echo(formatted) else: error = response.get("error", "Unknown error") - print(f"Error: {error}", file=sys.stderr) - sys.exit(1) + click.echo(f"Error: {error}", err=True) + raise SystemExit(1) if __name__ == "__main__": diff --git a/astrbot/core/platform/sources/cli/tcp_socket_server.py b/astrbot/core/platform/sources/cli/tcp_socket_server.py index 0016d15ed8..1e9cba3007 100644 --- a/astrbot/core/platform/sources/cli/tcp_socket_server.py +++ b/astrbot/core/platform/sources/cli/tcp_socket_server.py @@ -206,7 +206,7 @@ async def accept_connection(self) -> tuple[Any, Any]: logger.debug("[PROCESS] Waiting for client connection") # Use asyncio event loop for non-blocking accept - loop = asyncio.get_event_loop() + loop = asyncio.get_running_loop() client_socket, client_address = await loop.sock_accept(self.server_socket) logger.debug(f"[PROCESS] Connection accepted from {client_address}") From 2a9dbce5385e78f5227da545bfecf08720b888a1 Mon Sep 17 00:00:00 2001 From: YukiRa1n <167516635+YukiRa1n@users.noreply.github.com> Date: Fri, 6 Feb 2026 16:52:39 +0800 Subject: [PATCH 22/39] =?UTF-8?q?fix(cli):=20=E5=AE=8C=E5=96=84=E6=97=A7?= =?UTF-8?q?=E7=94=A8=E6=B3=95=E5=85=BC=E5=AE=B9=EF=BC=8Castr=20-j/--log?= =?UTF-8?q?=E7=AD=89flag=E8=87=AA=E5=8A=A8=E8=B7=AF=E7=94=B1=E5=88=B0?= =?UTF-8?q?=E5=AD=90=E5=91=BD=E4=BB=A4?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - astr -j "你好" → 自动路由到 astr send -j "你好" - astr -t 60 "你好" → 自动路由到 astr send -t 60 "你好" - astr --log → 自动路由到 astr log - 更新帮助文本，展示新旧两种用法 --- astrbot/cli/client/__main__.py | 28 ++++++++++++++++++++-------- 1 file changed, 20 insertions(+), 8 deletions(-) diff --git a/astrbot/cli/client/__main__.py b/astrbot/cli/client/__main__.py index 82c5a224ee..1f6c6dca85 100644 --- a/astrbot/cli/client/__main__.py +++ b/astrbot/cli/client/__main__.py @@ -430,21 +430,22 @@ def fix_git_bash_path(message: str) -> str: EPILOG = """使用示例: 发送消息: - astr 你好 直接发送（兼容旧用法） - astr send 你好 发送消息给 AstrBot + astr 你好 发送消息给 AstrBot + astr send 你好 同上（显式子命令） astr send /help 查看内置命令帮助 - echo "你好" | astr send 从标准输入读取 + echo "你好" | astr 从标准输入读取 获取日志: astr log 获取最近 100 行日志 + astr --log 同上（兼容旧用法） astr log --lines 50 获取最近 50 行 astr log --level ERROR 只显示 ERROR 级别 astr log --pattern "CLI" 只显示包含 "CLI" 的日志 astr log -j 以 JSON 格式输出日志 高级选项: - astr send -j "测试" 输出原始 JSON 响应 - astr send -t 60 "长时间任务" 设置超时时间为 60 秒 + astr -j "测试" 输出原始 JSON 响应 + astr -t 60 "长时间任务" 设置超时时间为 60 秒 连接说明: 自动从 data/.cli_connection 检测连接类型（Unix Socket 或 TCP） @@ -462,10 +463,21 @@ def format_epilog(self, ctx: click.Context, formatter: click.HelpFormatter) -> N for line in self.epilog.split("\n"): formatter.write(line + "\n") + # send 子命令的 option 前缀，用于识别 astr -j "你好" 等旧用法 + _send_opts = {"-j", "--json", "-t", "--timeout", "-s", "--socket"} + # --log 旧用法映射到 log 子命令 + _log_flag = {"--log"} + def parse_args(self, ctx: click.Context, args: list[str]) -> list[str]: - # 兼容旧用法: astr 你好 等价于 astr send 你好 - if args and args[0] not in self.commands and not args[0].startswith("-"): - args = ["send"] + args + if args: + first = args[0] + if first in self._log_flag: + # astr --log ... → astr log ... + args = ["log"] + args[1:] + elif first not in self.commands: + if not first.startswith("-") or first in self._send_opts: + # astr 你好 / astr -j "你好" → astr send ... + args = ["send"] + args return super().parse_args(ctx, args) From a952d67c7f5ea8b3b10eb5c673ed37d1605330ee Mon Sep 17 00:00:00 2001 From: YukiRa1n <167516635+YukiRa1n@users.noreply.github.com> Date: Sun, 8 Feb 2026 18:19:46 +0800 Subject: [PATCH 23/39] =?UTF-8?q?fix(cli):=20=E4=BF=AE=E5=A4=8D=E6=97=A5?= =?UTF-8?q?=E5=BF=97=E7=BA=A7=E5=88=AB=E7=AD=9B=E9=80=89=E5=8A=9F=E8=83=BD?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit 问题： - `astr log --level ERROR` 无法筛选到 [ERRO] 日志 - 日志文件使用4字符缩写 [ERRO]/[WARN]/[INFO] - 但用户输入的是完整名称 ERROR/WARN/INFO 修复： - 添加 LEVEL_MAP 映射表，将完整名称映射到缩写 ERROR -> ERRO, WARNING -> WARN, CRITICAL -> CRIT - 使用正则表达式精确匹配 [级别] 格式 - 避免 ERROR 错误匹配到 ERROR_INFO 等字符串 测试： - `astr log --level ERROR` ✅ 筛选 [ERRO] 日志 - `astr log --level WARN` ✅ 筛选 [WARN] 日志 - `astr log --level WARNING` ✅ 映射到 [WARN] --- .../sources/cli/handlers/socket_handler.py | 21 ++++++++++++++++--- 1 file changed, 18 insertions(+), 3 deletions(-) diff --git a/astrbot/core/platform/sources/cli/handlers/socket_handler.py b/astrbot/core/platform/sources/cli/handlers/socket_handler.py index 74c4e75179..be2b9e59da 100644 --- a/astrbot/core/platform/sources/cli/handlers/socket_handler.py +++ b/astrbot/core/platform/sources/cli/handlers/socket_handler.py @@ -6,6 +6,7 @@ import asyncio import json import os +import re import uuid from collections.abc import Callable from typing import TYPE_CHECKING @@ -203,10 +204,22 @@ async def _get_logs(self, request: dict, request_id: str) -> str: Returns: JSON格式的响应字符串 """ + # 日志级别映射：完整名称 -> 日志文件中的缩写 + LEVEL_MAP = { + "DEBUG": "DEBUG", + "INFO": "INFO", + "WARNING": "WARN", + "WARN": "WARN", + "ERROR": "ERRO", + "CRITICAL": "CRIT", + } + try: # 获取参数 lines = min(request.get("lines", 100), 1000) # 最多1000行 level_filter = request.get("level", "").upper() + # 映射到日志文件中的缩写 + level_filter = LEVEL_MAP.get(level_filter, level_filter) pattern = request.get("pattern", "") # 日志文件路径 @@ -236,9 +249,11 @@ async def _get_logs(self, request: dict, request_id: str) -> str: if not line.strip(): continue - # 级别过滤 - if level_filter and level_filter not in line: - continue + # 级别过滤（匹配 [级别] 格式） + if level_filter: + # 匹配 [级别] 格式，例如 [ERRO], [WARN], [INFO] + if not re.search(rf'\[{level_filter}\]', line): + continue # 模式过滤 if pattern and pattern not in line: From fe1095aeb5a28a9d9dcf9ed26993ace9fc620e1f Mon Sep 17 00:00:00 2001 From: YukiRa1n <167516635+YukiRa1n@users.noreply.github.com> Date: Sun, 8 Feb 2026 19:50:33 +0800 Subject: [PATCH 24/39] =?UTF-8?q?feat(cli):=20=E9=BB=98=E8=AE=A4=E4=BD=BF?= =?UTF-8?q?=E7=94=A8=E6=96=87=E4=BB=B6=E6=A8=A1=E5=BC=8F=E8=AF=BB=E5=8F=96?= =?UTF-8?q?=E6=97=A5=E5=BF=97?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - 默认直接读取日志文件，无需 AstrBot 运行 - 添加 --socket 参数，保留通过 Socket 获取日志的功能 - 正则表达式在文件模式下完全支持，无转义问题 - 简化使用，提高可靠性 示例: astr log # 默认：直接读取文件 astr log --level ERROR # 筛选 ERROR 级别 astr log --pattern "ERRO|WARN" --regex # 正则匹配 astr log --socket # 通过 Socket 获取（需 AstrBot 运行） --- astrbot/cli/client/__main__.py | 136 ++++++++++++++++-- .../sources/cli/handlers/socket_handler.py | 19 ++- 2 files changed, 139 insertions(+), 16 deletions(-) diff --git a/astrbot/cli/client/__main__.py b/astrbot/cli/client/__main__.py index 1f6c6dca85..998f76bbfd 100644 --- a/astrbot/cli/client/__main__.py +++ b/astrbot/cli/client/__main__.py @@ -284,6 +284,7 @@ def get_logs( lines: int = 100, level: str = "", pattern: str = "", + use_regex: bool = False, ) -> dict: """获取AstrBot日志 @@ -293,6 +294,7 @@ def get_logs( lines: 返回的日志行数 level: 日志级别过滤 pattern: 模式过滤 + use_regex: 是否使用正则表达式 Returns: 响应字典 @@ -309,6 +311,7 @@ def get_logs( "lines": lines, "level": level, "pattern": pattern, + "regex": use_regex, } # 添加token @@ -436,12 +439,13 @@ def fix_git_bash_path(message: str) -> str: echo "你好" | astr 从标准输入读取 获取日志: - astr log 获取最近 100 行日志 + astr log 获取最近 100 行日志（直接读取文件） astr --log 同上（兼容旧用法） astr log --lines 50 获取最近 50 行 astr log --level ERROR 只显示 ERROR 级别 astr log --pattern "CLI" 只显示包含 "CLI" 的日志 - astr log -j 以 JSON 格式输出日志 + astr log --pattern "ERRO|WARN" --regex 使用正则表达式匹配 + astr log --socket 通过 Socket 连接 AstrBot 获取 高级选项: astr -j "测试" 输出原始 JSON 响应 @@ -546,28 +550,49 @@ def _do_send(msg: str, socket_path: str | None, timeout: float, use_json: bool) "--level", default="", help="按级别过滤 (DEBUG/INFO/WARNING/ERROR/CRITICAL)" ) @click.option("--pattern", default="", help="按模式过滤（子串匹配）") -@click.option("-s", "--socket", "socket_path", default=None, help="Unix socket 路径") -@click.option("-t", "--timeout", default=30.0, type=float, help="超时时间（秒）") -@click.option("-j", "--json", "use_json", is_flag=True, help="输出原始 JSON 响应") +@click.option("--regex", is_flag=True, help="使用正则表达式匹配 pattern") +@click.option( + "--socket", + "use_socket", + is_flag=True, + help="通过 Socket 连接 AstrBot 获取日志（需要 AstrBot 运行）", +) +@click.option( + "-t", "--timeout", default=30.0, type=float, help="超时时间（仅 Socket 模式）" +) def log( lines: int, level: str, pattern: str, - socket_path: str | None, + regex: bool, + use_socket: bool, timeout: float, - use_json: bool, ) -> None: """获取 AstrBot 日志 \b 示例: - astr log - astr log --lines 50 - astr log --level ERROR - astr log --pattern "plugin" + astr log # 直接读取日志文件（默认） + astr log --lines 50 # 获取最近 50 行 + astr log --level ERROR # 只显示 ERROR 级别 + astr log --pattern "plugin" # 匹配包含 "plugin" 的日志 + astr log --pattern "ERRO|WARN" --regex # 使用正则表达式 + astr log --socket # 通过 Socket 连接 AstrBot 获取 """ - response = get_logs(socket_path, timeout, lines, level, pattern) - _output_response(response, use_json) + if use_socket: + # 通过 Socket 获取日志 + response = get_logs(None, timeout, lines, level, pattern, regex) + # 输出响应（复用 _output_response，但不需要 use_json 参数） + if response.get("status") == "success": + formatted = response.get("response", "") + click.echo(formatted) + else: + error = response.get("error", "Unknown error") + click.echo(f"Error: {error}", err=True) + raise SystemExit(1) + else: + # 直接读取日志文件（默认） + _read_log_from_file(lines, level, pattern, regex) def _output_response(response: dict, use_json: bool) -> None: @@ -584,5 +609,90 @@ def _output_response(response: dict, use_json: bool) -> None: raise SystemExit(1) +def _read_log_from_file(lines: int, level: str, pattern: str, use_regex: bool) -> None: + """直接从日志文件读取 + + Args: + lines: 返回的日志行数 + level: 日志级别过滤 + pattern: 模式过滤 + use_regex: 是否使用正则表达式 + """ + import re + + # 日志级别映射 + LEVEL_MAP = { + "DEBUG": "DEBUG", + "INFO": "INFO", + "WARNING": "WARN", + "WARN": "WARN", + "ERROR": "ERRO", + "CRITICAL": "CRIT", + } + + # 映射级别 + level_filter = LEVEL_MAP.get(level.upper(), level.upper()) + + # 日志文件路径 + log_path = os.path.join(get_data_path(), "logs", "astrbot.log") + + if not os.path.exists(log_path): + click.echo( + f"Error: 日志文件未找到: {log_path}", + err=True, + ) + click.echo( + "提示: 请在配置中启用 log_file_enable 来记录日志到文件，或使用不带 --file 的方式连接 AstrBot", + err=True, + ) + raise SystemExit(1) + + try: + with open(log_path, encoding="utf-8", errors="ignore") as f: + all_lines = f.readlines() + + # 从末尾开始筛选 + logs = [] + for line in reversed(all_lines): + # 跳过空行 + if not line.strip(): + continue + + # 级别过滤 + if level_filter: + if not re.search(rf"\[{level_filter}\]", line): + continue + + # 模式过滤 + if pattern: + if use_regex: + try: + if not re.search(pattern, line): + continue + except re.error: + # 正则表达式错误，回退到子串匹配 + if pattern not in line: + continue + else: + if pattern not in line: + continue + + logs.append(line.rstrip()) + + if len(logs) >= lines: + break + + # 反转回来（使时间顺序正确） + logs.reverse() + + # 输出 + for log_line in logs: + click.echo(log_line) + + except OSError as e: + click.echo(f"Error: 读取日志文件失败: {e}", err=True) + raise SystemExit(1) + + if __name__ == "__main__": main() diff --git a/astrbot/core/platform/sources/cli/handlers/socket_handler.py b/astrbot/core/platform/sources/cli/handlers/socket_handler.py index be2b9e59da..73ade8ffc2 100644 --- a/astrbot/core/platform/sources/cli/handlers/socket_handler.py +++ b/astrbot/core/platform/sources/cli/handlers/socket_handler.py @@ -221,6 +221,9 @@ async def _get_logs(self, request: dict, request_id: str) -> str: # 映射到日志文件中的缩写 level_filter = LEVEL_MAP.get(level_filter, level_filter) pattern = request.get("pattern", "") + use_regex = request.get("regex", False) # 是否使用正则表达式 + + logger.debug(f"[LogFilter] lines={lines}, level={level_filter}, pattern={repr(pattern)}, regex={use_regex}") # 日志文件路径 log_path = os.path.join(self.data_path, "logs", "astrbot.log") @@ -255,9 +258,19 @@ async def _get_logs(self, request: dict, request_id: str) -> str: if not re.search(rf'\[{level_filter}\]', line): continue - # 模式过滤 - if pattern and pattern not in line: - continue + # 模式过滤（支持正则表达式） + if pattern: + if use_regex: + try: + if not re.search(pattern, line): + continue + except re.error: + # 正则表达式错误，回退到子串匹配 + if pattern not in line: + continue + else: + if pattern not in line: + continue logs.append(line.rstrip()) From be7bede94a5b6bdeb3af313c86b291b61f3c2a92 Mon Sep 17 00:00:00 2001 From: YukiRa1n <167516635+YukiRa1n@users.noreply.github.com> Date: Tue, 10 Feb 2026 18:50:44 +0800 Subject: [PATCH 25/39] =?UTF-8?q?fix(cli):=20=E4=BF=AE=E5=A4=8D=E6=8F=92?= =?UTF-8?q?=E4=BB=B6=E6=8C=87=E4=BB=A4=E6=89=A7=E8=A1=8C=E5=90=8E=E8=A7=A6?= =?UTF-8?q?=E5=8F=91=20LLM=20=E5=9B=9E=E5=A4=8D=E7=9A=84=E9=97=AE=E9=A2=98?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- astrbot/core/platform/sources/cli/cli_event.py | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/astrbot/core/platform/sources/cli/cli_event.py b/astrbot/core/platform/sources/cli/cli_event.py index 5c6eaecb1d..a63e2b5378 100644 --- a/astrbot/core/platform/sources/cli/cli_event.py +++ b/astrbot/core/platform/sources/cli/cli_event.py @@ -55,6 +55,10 @@ def __init__( async def send(self, message_chain: MessageChain) -> dict[str, Any]: """发送消息到CLI""" + # 调用父类方法以设置 _has_send_oper 标志 + # 这告诉 ProcessStage 已经有发送操作，避免触发 LLM + await super().send(message_chain) + # Socket模式：收集多次回复 if self.response_future is not None and not self.response_future.done(): # 使用 ImageProcessor 预处理图片（避免临时文件被删除） From 079d60ca089ccc2e9cf8b829cae9cde46c8c4940 Mon Sep 17 00:00:00 2001 From: YukiRa1n <167516635+YukiRa1n@users.noreply.github.com> Date: Tue, 10 Feb 2026 21:29:27 +0800 Subject: [PATCH 26/39] =?UTF-8?q?feat(cli):=20=E6=B7=BB=E5=8A=A0=E9=87=8D?= =?UTF-8?q?=E5=90=AF=E5=91=BD=E4=BB=A4=E5=92=8C=E5=8F=AF=E9=80=89=E7=9A=84?= =?UTF-8?q?=E6=96=B0=E7=AA=97=E5=8F=A3=E5=90=AF=E5=8A=A8?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - 修复 CLI 适配器插件指令执行后触发 LLM 的问题 - 新增 restart 命令，支持停止并重启 AstrBot 实例 - 添加 --window 选项，Windows 下可在新窗口启动 - Linux/macOS 默认在当前窗口运行（服务器环境） - Windows 默认在当前窗口，可选 --window 在新窗口启动 --- astrbot/cli/__main__.py | 3 +- astrbot/cli/commands/__init__.py | 3 +- astrbot/cli/commands/cmd_restart.py | 325 ++++++++++++++++++++++++++++ astrbot/cli/commands/cmd_run.py | 122 ++++++++++- 4 files changed, 442 insertions(+), 11 deletions(-) create mode 100644 astrbot/cli/commands/cmd_restart.py diff --git a/astrbot/cli/__main__.py b/astrbot/cli/__main__.py index 40c46de79d..47f5a8eec5 100644 --- a/astrbot/cli/__main__.py +++ b/astrbot/cli/__main__.py @@ -5,7 +5,7 @@ import click from . import __version__ -from .commands import conf, init, plug, run +from .commands import conf, init, plug, restart, run logo_tmpl = r""" ___ _______.___________..______ .______ ______ .___________. @@ -51,6 +51,7 @@ def help(command_name: str | None) -> None: cli.add_command(init) cli.add_command(run) +cli.add_command(restart) cli.add_command(help) cli.add_command(plug) cli.add_command(conf) diff --git a/astrbot/cli/commands/__init__.py b/astrbot/cli/commands/__init__.py index 1d3e0bca2f..69c22a2183 100644 --- a/astrbot/cli/commands/__init__.py +++ b/astrbot/cli/commands/__init__.py @@ -1,6 +1,7 @@ from .cmd_conf import conf from .cmd_init import init from .cmd_plug import plug +from .cmd_restart import restart from .cmd_run import run -__all__ = ["conf", "init", "plug", "run"] +__all__ = ["conf", "init", "plug", "restart", "run"] diff --git a/astrbot/cli/commands/cmd_restart.py b/astrbot/cli/commands/cmd_restart.py new file mode 100644 index 0000000000..594ef7828b --- /dev/null +++ b/astrbot/cli/commands/cmd_restart.py @@ -0,0 +1,325 @@ +import asyncio +import os +import signal +import subprocess +import sys +import time +from pathlib import Path + +import click +from filelock import FileLock, Timeout + +from ..utils import check_astrbot_root, check_dashboard, get_astrbot_root + + +async def run_astrbot(astrbot_root: Path): + """运行 AstrBot""" + from astrbot.core import LogBroker, LogManager, db_helper, logger + from astrbot.core.initial_loader import InitialLoader + + await check_dashboard(astrbot_root / "data") + + log_broker = LogBroker() + LogManager.set_queue_handler(logger, log_broker) + db = db_helper + + core_lifecycle = InitialLoader(db, log_broker) + + await core_lifecycle.start() + + +def launch_in_new_window( + astrbot_root: Path, + reload: bool, + port: str | None, +) -> None: + """在新窗口启动 AstrBot（仅 Windows）""" + python_exe = sys.executable + + # 构建命令，添加 --no-window 标志 + cmd = [python_exe, "-m", "astrbot.cli", "run", "--no-window"] + + if reload: + cmd.append("-r") + + if port: + cmd.extend(["-p", port]) + + # 设置环境变量 + env = os.environ.copy() + env["ASTRBOT_CLI"] = "1" + env["ASTRBOT_ROOT"] = str(astrbot_root) + + if port: + env["DASHBOARD_PORT"] = port + + if reload: + env["ASTRBOT_RELOAD"] = "1" + + if sys.platform == "win32": + # Windows: 使用 powershell 开新窗口 + cmd_str = " ".join(f'"{c}"' if " " in str(c) else str(c) for c in cmd) + ps_script = f'Start-Process powershell -ArgumentList "-NoExit", "-Command", "cd {astrbot_root}; {cmd_str}" -WindowStyle Normal' + subprocess.Popen( + ["powershell", "-Command", ps_script], + env=env, + shell=False, + ) + elif sys.platform == "darwin": + # macOS: 使用 osascript 打开新的 Terminal 窗口 + cmd_str = " ".join(cmd) + script = f""" + tell application "Terminal" + do script "cd {astrbot_root} && {cmd_str}" + activate + end tell + """ + subprocess.Popen(["osascript", "-e", script], env=env) + else: + # Linux: 使用 gnome-terminal 或 xterm + cmd_str = " ".join(cmd) + for term_cmd in ["gnome-terminal", "xterm", "konsole", "xfce4-terminal"]: + try: + if term_cmd == "gnome-terminal": + subprocess.Popen( + [ + term_cmd, + "--", + "bash", + "-c", + f"cd {astrbot_root} && {cmd_str}; exec bash", + ], + env=env, + ) + else: + subprocess.Popen( + [ + term_cmd, + "-e", + "bash", + "-c", + f"cd {astrbot_root} && {cmd_str}; exec bash", + ], + env=env, + ) + break + except FileNotFoundError: + continue + else: + raise click.ClickException( + "无法找到终端模拟器，请手动安装 gnome-terminal 或 xterm" + ) + + +def find_and_kill_astrbot_processes(astrbot_root: Path) -> bool: + """查找并终止正在运行的 AstrBot 进程 + + Returns: + bool: 是否成功终止了进程 + """ + killed = False + current_pid = os.getpid() + + if sys.platform == "win32": + # Windows: 使用 wmic 获取进程命令行，精确匹配 AstrBot 进程 + import subprocess + + try: + # 使用 wmic 获取所有 python.exe 进程的命令行 + result = subprocess.run( + [ + "wmic", + "process", + "where", + "name='python.exe'", + "get", + "processid,commandline", + "/format:csv", + ], + capture_output=True, + text=True, + timeout=10, + ) + + # 解析输出并终止相关进程 + for line in result.stdout.split("\n"): + if not line.strip() or "CommandLine" in line: + continue + + parts = line.split(",") + if len(parts) >= 3: + _, cmdline, pid_str = ( + parts[0].strip('"'), + parts[1].strip('"'), + parts[2].strip('"'), + ) + + try: + pid = int(pid_str) + + # 跳过当前进程 + if pid == current_pid: + continue + + # 只终止包含 astrbot 的进程 + # 匹配: astrbot, astrbot.exe, astrbot run, -m astrbot 等 + cmdline_lower = cmdline.lower() + if "astrbot" in cmdline_lower or "astrbot.exe" in cmdline_lower: + subprocess.run( + ["taskkill", "/F", "/PID", str(pid)], + capture_output=True, + timeout=5, + ) + click.echo(f"已终止进程: {pid}") + killed = True + except (ValueError, subprocess.TimeoutExpired): + continue + except (subprocess.CalledProcessError, FileNotFoundError, Exception) as e: + click.echo(f"查找进程时出错: {e}") + + else: + # Unix/Linux/macOS: 使用 ps 和 kill + import subprocess + + try: + # 使用 ps 获取完整命令行，精确匹配 + result = subprocess.run( + ["ps", "aux"], + capture_output=True, + text=True, + timeout=10, + ) + + for line in result.stdout.split("\n"): + # 跳过标题行 + if line.startswith("USER"): + continue + + # 检查是否是 python 进程且包含 astrbot + if "python" in line.lower() and "astrbot" in line.lower(): + parts = line.split(None, 10) # 最多分割10次，保留完整命令行 + if len(parts) >= 2: + try: + pid = int(parts[1]) + + # 跳过当前进程 + if pid == current_pid: + continue + + os.kill(pid, signal.SIGTERM) + click.echo(f"已发送 SIGTERM 到进程: {pid}") + killed = True + except (ValueError, ProcessLookupError): + continue + except Exception as e: + click.echo(f"查找进程时出错: {e}") + + return killed + + +@click.option("--reload", "-r", is_flag=True, help="启用插件自动重载") +@click.option("--port", "-p", help="Dashboard 端口", required=False, type=str) +@click.option( + "--force", + "-f", + is_flag=True, + help="强制重启，即使无法清理锁文件也尝试启动", +) +@click.option( + "--wait-time", + type=float, + default=3.0, + help="等待进程退出的时间（秒）", +) +@click.option( + "--window", + "-w", + is_flag=True, + help="在新窗口中重启（仅 Windows）", +) +@click.command() +def restart( + reload: bool, + port: str, + force: bool, + wait_time: float, + window: bool, +) -> None: + """重启 AstrBot（Linux/macOS 默认当前窗口，Windows 可选 --window）""" + try: + os.environ["ASTRBOT_CLI"] = "1" + astrbot_root = get_astrbot_root() + + if not check_astrbot_root(astrbot_root): + raise click.ClickException( + f"{astrbot_root}不是有效的 AstrBot 根目录，如需初始化请使用 astrbot init", + ) + + os.environ["ASTRBOT_ROOT"] = str(astrbot_root) + sys.path.insert(0, str(astrbot_root)) + + if port: + os.environ["DASHBOARD_PORT"] = port + + if reload: + os.environ["ASTRBOT_RELOAD"] = "1" + + lock_file = astrbot_root / "astrbot.lock" + + # 尝试获取锁，如果成功说明没有实例在运行 + lock = FileLock(lock_file, timeout=1) + + try: + lock.acquire() + lock.release() + except Timeout: + # 锁文件存在，有实例在运行 + click.echo("检测到正在运行的实例，正在停止...") + + # 1. 先尝试通过查找并终止进程 + killed = find_and_kill_astrbot_processes(astrbot_root) + + if killed: + click.echo(f"等待 {wait_time} 秒以确保进程退出...") + time.sleep(wait_time) + + # 2. 尝试删除锁文件（可能需要重试） + max_retries = 5 + for i in range(max_retries): + try: + lock_file.unlink(missing_ok=True) + break + except PermissionError: + if i < max_retries - 1: + time.sleep(1) + else: + # 最后一次尝试：使用 FileLock 强制获取 + try: + force_lock = FileLock(lock_file, timeout=1) + force_lock.acquire(force=True) + force_lock.release() + lock_file.unlink(missing_ok=True) + except Exception: + pass + + # 重新启动 + # Windows: 如果指定了 --window，在新窗口启动 + # Linux/macOS: 始终在当前窗口运行 + if sys.platform == "win32" and window: + launch_in_new_window(astrbot_root, reload, port) + click.echo("[OK] AstrBot 已在新窗口中重启") + return + + # 在当前窗口运行（Linux/macOS 默认，Windows 默认） + lock = FileLock(lock_file, timeout=5) + with lock: + asyncio.run(run_astrbot(astrbot_root)) + + except KeyboardInterrupt: + click.echo("\nAstrBot 已关闭...") + except Timeout: + raise click.ClickException( + "无法获取锁文件，请使用 --force 参数强制重启", + ) + except Exception as e: + raise click.ClickException(f"运行时出现错误: {e}") diff --git a/astrbot/cli/commands/cmd_run.py b/astrbot/cli/commands/cmd_run.py index 23665dff3d..38b6d95868 100644 --- a/astrbot/cli/commands/cmd_run.py +++ b/astrbot/cli/commands/cmd_run.py @@ -1,5 +1,6 @@ import asyncio import os +import subprocess import sys import traceback from pathlib import Path @@ -26,20 +27,123 @@ async def run_astrbot(astrbot_root: Path) -> None: await core_lifecycle.start() +def launch_in_new_window( + astrbot_root: Path, + reload: bool, + port: str | None, +) -> None: + """在新窗口启动 AstrBot（仅 Windows）""" + python_exe = sys.executable + + # 构建命令，添加 --no-window 标志表示在当前窗口运行 + cmd = [python_exe, "-m", "astrbot.cli", "run", "--no-window"] + + if reload: + cmd.append("-r") + + if port: + cmd.extend(["-p", port]) + + # 设置环境变量 + env = os.environ.copy() + env["ASTRBOT_CLI"] = "1" + env["ASTRBOT_ROOT"] = str(astrbot_root) + + if port: + env["DASHBOARD_PORT"] = port + + if reload: + env["ASTRBOT_RELOAD"] = "1" + + if sys.platform == "win32": + # Windows: 使用 start 命令开新窗口 + cmd_str = " ".join(f'"{c}"' if " " in str(c) else str(c) for c in cmd) + ps_script = f'Start-Process powershell -ArgumentList "-NoExit", "-Command", "cd {astrbot_root}; {cmd_str}" -WindowStyle Normal' + subprocess.Popen( + ["powershell", "-Command", ps_script], + env=env, + shell=False, + ) + elif sys.platform == "darwin": + # macOS: 使用 osascript 打开新的 Terminal 窗口 + cmd_str = " ".join(cmd) + script = f""" + tell application "Terminal" + do script "cd {astrbot_root} && {cmd_str}" + activate + end tell + """ + subprocess.Popen(["osascript", "-e", script], env=env) + else: + # Linux: 使用 gnome-terminal 或 xterm + cmd_str = " ".join(cmd) + for term_cmd in ["gnome-terminal", "xterm", "konsole", "xfce4-terminal"]: + try: + if term_cmd == "gnome-terminal": + subprocess.Popen( + [ + term_cmd, + "--", + "bash", + "-c", + f"cd {astrbot_root} && {cmd_str}; exec bash", + ], + env=env, + ) + else: + subprocess.Popen( + [ + term_cmd, + "-e", + "bash", + "-c", + f"cd {astrbot_root} && {cmd_str}; exec bash", + ], + env=env, + ) + break + except FileNotFoundError: + continue + else: + raise click.ClickException( + "无法找到终端模拟器，请手动安装 gnome-terminal 或 xterm" + ) + + @click.option("--reload", "-r", is_flag=True, help="插件自动重载") @click.option("--port", "-p", help="Astrbot Dashboard端口", required=False, type=str) +@click.option( + "--window", + "-w", + is_flag=True, + help="在新窗口中启动（仅 Windows）", +) +@click.option( + "--no-window", + is_flag=True, + hidden=True, + help="在当前窗口运行（内部使用）", +) @click.command() -def run(reload: bool, port: str) -> None: - """运行 AstrBot""" - try: - os.environ["ASTRBOT_CLI"] = "1" - astrbot_root = get_astrbot_root() +def run(reload: bool, port: str, window: bool, no_window: bool) -> None: + """运行 AstrBot（Linux/macOS 默认当前窗口，Windows 可选 --window）""" + os.environ["ASTRBOT_CLI"] = "1" + astrbot_root = get_astrbot_root() - if not check_astrbot_root(astrbot_root): - raise click.ClickException( - f"{astrbot_root}不是有效的 AstrBot 根目录，如需初始化请使用 astrbot init", - ) + if not check_astrbot_root(astrbot_root): + raise click.ClickException( + f"{astrbot_root}不是有效的 AstrBot 根目录，如需初始化请使用 astrbot init", + ) + # Windows: 如果指定了 --window 且不是 --no-window，在新窗口启动 + # Linux/macOS: 始终在当前窗口运行 + if sys.platform == "win32" and window and not no_window: + launch_in_new_window(astrbot_root, reload, port) + click.echo("[OK] AstrBot 已在新窗口中启动") + return + + # 在当前窗口运行（Linux/macOS 默认，Windows 默认或指定 --no-window） + try: os.environ["ASTRBOT_ROOT"] = str(astrbot_root) sys.path.insert(0, str(astrbot_root)) From 4ec2f604636d21b162ba62c44ad28ddac8a1c95b Mon Sep 17 00:00:00 2001 From: YukiRa1n <167516635+YukiRa1n@users.noreply.github.com> Date: Tue, 10 Feb 2026 21:33:27 +0800 Subject: [PATCH 27/39] =?UTF-8?q?feat(cli):=20Windows=20=E9=BB=98=E8=AE=A4?= =?UTF-8?q?=E5=9C=A8=E6=96=B0=E7=AA=97=E5=8F=A3=E5=90=AF=E5=8A=A8?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - Windows 默认在新窗口启动，使用 --no-window 在当前窗口 - Linux/macOS 始终在当前窗口运行（服务器环境） - 修改 run 和 restart 命令的行为 --- astrbot/cli/commands/cmd_restart.py | 17 ++++++++--------- astrbot/cli/commands/cmd_run.py | 19 ++++++------------- 2 files changed, 14 insertions(+), 22 deletions(-) diff --git a/astrbot/cli/commands/cmd_restart.py b/astrbot/cli/commands/cmd_restart.py index 594ef7828b..e0d10d802e 100644 --- a/astrbot/cli/commands/cmd_restart.py +++ b/astrbot/cli/commands/cmd_restart.py @@ -36,7 +36,7 @@ def launch_in_new_window( """在新窗口启动 AstrBot（仅 Windows）""" python_exe = sys.executable - # 构建命令，添加 --no-window 标志 + # 构建命令，添加 --no-window 标志让新窗口在当前窗口运行 cmd = [python_exe, "-m", "astrbot.cli", "run", "--no-window"] if reload: @@ -232,10 +232,9 @@ def find_and_kill_astrbot_processes(astrbot_root: Path) -> bool: help="等待进程退出的时间（秒）", ) @click.option( - "--window", - "-w", + "--no-window", is_flag=True, - help="在新窗口中重启（仅 Windows）", + help="在当前窗口重启（仅 Windows）", ) @click.command() def restart( @@ -243,9 +242,9 @@ def restart( port: str, force: bool, wait_time: float, - window: bool, + no_window: bool, ) -> None: - """重启 AstrBot（Linux/macOS 默认当前窗口，Windows 可选 --window）""" + """重启 AstrBot（Windows 默认新窗口，Linux/macOS 当前窗口）""" try: os.environ["ASTRBOT_CLI"] = "1" astrbot_root = get_astrbot_root() @@ -303,14 +302,14 @@ def restart( pass # 重新启动 - # Windows: 如果指定了 --window，在新窗口启动 + # Windows: 默认在新窗口启动（除非指定 --no-window） # Linux/macOS: 始终在当前窗口运行 - if sys.platform == "win32" and window: + if sys.platform == "win32" and not no_window: launch_in_new_window(astrbot_root, reload, port) click.echo("[OK] AstrBot 已在新窗口中重启") return - # 在当前窗口运行（Linux/macOS 默认，Windows 默认） + # 在当前窗口运行（Linux/macOS 默认，Windows 指定 --no-window） lock = FileLock(lock_file, timeout=5) with lock: asyncio.run(run_astrbot(astrbot_root)) diff --git a/astrbot/cli/commands/cmd_run.py b/astrbot/cli/commands/cmd_run.py index 38b6d95868..2ca9e3ee4d 100644 --- a/astrbot/cli/commands/cmd_run.py +++ b/astrbot/cli/commands/cmd_run.py @@ -112,21 +112,14 @@ def launch_in_new_window( @click.option("--reload", "-r", is_flag=True, help="插件自动重载") @click.option("--port", "-p", help="Astrbot Dashboard端口", required=False, type=str) -@click.option( - "--window", - "-w", - is_flag=True, - help="在新窗口中启动（仅 Windows）", -) @click.option( "--no-window", is_flag=True, - hidden=True, - help="在当前窗口运行（内部使用）", + help="在当前窗口运行（仅 Windows）", ) @click.command() -def run(reload: bool, port: str, window: bool, no_window: bool) -> None: - """运行 AstrBot（Linux/macOS 默认当前窗口，Windows 可选 --window）""" +def run(reload: bool, port: str, no_window: bool) -> None: + """运行 AstrBot（Windows 默认新窗口，Linux/macOS 当前窗口）""" os.environ["ASTRBOT_CLI"] = "1" astrbot_root = get_astrbot_root() @@ -135,14 +128,14 @@ def run(reload: bool, port: str, window: bool, no_window: bool) -> None: f"{astrbot_root}不是有效的 AstrBot 根目录，如需初始化请使用 astrbot init", ) - # Windows: 如果指定了 --window 且不是 --no-window，在新窗口启动 + # Windows: 默认在新窗口启动（除非指定 --no-window） # Linux/macOS: 始终在当前窗口运行 - if sys.platform == "win32" and window and not no_window: + if sys.platform == "win32" and not no_window: launch_in_new_window(astrbot_root, reload, port) click.echo("[OK] AstrBot 已在新窗口中启动") return - # 在当前窗口运行（Linux/macOS 默认，Windows 默认或指定 --no-window） + # 在当前窗口运行（Linux/macOS 默认，Windows 指定 --no-window） try: os.environ["ASTRBOT_ROOT"] = str(astrbot_root) sys.path.insert(0, str(astrbot_root)) From 5833ff780282d0e790061ea69ebb2f8f56e992dc Mon Sep 17 00:00:00 2001 From: YukiRa1n <167516635+YukiRa1n@users.noreply.github.com> Date: Thu, 12 Feb 2026 11:49:19 +0800 Subject: [PATCH 28/39] =?UTF-8?q?fix(cli):=20=E4=BC=98=E5=8C=96=E6=B6=88?= =?UTF-8?q?=E6=81=AF=E6=8E=A5=E6=94=B6=E9=80=BB=E8=BE=91=EF=BC=8C=E7=94=A8?= =?UTF-8?q?=20finalize=20=E6=9C=BA=E5=88=B6=E6=9B=BF=E4=BB=A3=E5=BB=B6?= =?UTF-8?q?=E8=BF=9F=E5=93=8D=E5=BA=94?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - CLIMessageEvent: 用 finalize() 替代 _delayed_response() 延迟机制， 管道完成后统一返回响应，解决工具调用响应截断问题 - CLIMessageEvent: 添加 send_streaming() 支持，采用收集后一次性发送策略 - SocketClientHandler: 超时从30s增加到120s，处理 finalize 返回 None 的情况 - PipelineScheduler: 管道完成后调用 event.finalize()（鸭子类型） - CLIAdapter: 添加 get_stats()/unified_webhook() 兼容 CLIConfig 数据类 - PlatformManager: 安全获取平台ID，兼容 dict 和 dataclass 类型 - PlatformRoute: 兼容 CLIConfig 的 webhook_uuid 获取方式 - MessageConverter: 补充 raw_message 字段 --- astrbot/core/pipeline/scheduler.py | 4 + astrbot/core/platform/manager.py | 12 ++- .../core/platform/sources/cli/cli_adapter.py | 33 ++++++++ .../core/platform/sources/cli/cli_event.py | 75 ++++++++++--------- .../sources/cli/handlers/socket_handler.py | 14 ++-- .../platform/sources/cli/message/converter.py | 2 + astrbot/dashboard/routes/platform.py | 4 +- 7 files changed, 100 insertions(+), 44 deletions(-) diff --git a/astrbot/core/pipeline/scheduler.py b/astrbot/core/pipeline/scheduler.py index ffb9c5c99c..07017d79a0 100644 --- a/astrbot/core/pipeline/scheduler.py +++ b/astrbot/core/pipeline/scheduler.py @@ -90,6 +90,10 @@ async def execute(self, event: AstrMessageEvent) -> None: if isinstance(event, WebChatMessageEvent | WecomAIBotMessageEvent): await event.send(None) + # 通知事件管道已完成（鸭子类型，供需要收集完整响应的适配器使用） + if hasattr(event, "finalize"): + await event.finalize() + logger.debug("pipeline 执行完毕。") finally: active_event_registry.unregister(event) diff --git a/astrbot/core/platform/manager.py b/astrbot/core/platform/manager.py index dc29665000..3c2ef01ba9 100644 --- a/astrbot/core/platform/manager.py +++ b/astrbot/core/platform/manager.py @@ -296,6 +296,16 @@ async def terminate(self) -> None: def get_insts(self): return self.platform_insts + @staticmethod + def _get_platform_id(inst) -> str: + """安全获取平台ID，兼容dict和dataclass类型的config""" + config = getattr(inst, "config", None) + if config is None: + return "unknown" + if isinstance(config, dict): + return config.get("id", "unknown") + return getattr(config, "platform_id", getattr(config, "id", "unknown")) + def get_all_stats(self) -> dict: """获取所有平台的统计信息 @@ -321,7 +331,7 @@ def get_all_stats(self) -> dict: logger.warning(f"获取平台统计信息失败: {e}") stats_list.append( { - "id": getattr(inst, "config", {}).get("id", "unknown"), + "id": self._get_platform_id(inst), "type": "unknown", "status": "unknown", "error_count": 0, diff --git a/astrbot/core/platform/sources/cli/cli_adapter.py b/astrbot/core/platform/sources/cli/cli_adapter.py index c62dc2d12b..d070eb3c57 100644 --- a/astrbot/core/platform/sources/cli/cli_adapter.py +++ b/astrbot/core/platform/sources/cli/cli_adapter.py @@ -195,6 +195,39 @@ def meta(self) -> PlatformMetadata: """获取平台元数据""" return self.metadata + def unified_webhook(self) -> bool: + """CLI不使用webhook""" + return False + + def get_stats(self) -> dict: + """获取平台统计信息（兼容CLIConfig数据类）""" + meta = self.meta() + meta_info = { + "id": meta.id, + "name": meta.name, + "display_name": meta.adapter_display_name or meta.name, + "description": meta.description, + "support_streaming_message": meta.support_streaming_message, + "support_proactive_message": meta.support_proactive_message, + } + return { + "id": meta.id or self.config.platform_id, + "type": meta.name, + "display_name": meta.adapter_display_name or meta.name, + "status": self._status.value, + "started_at": self._started_at.isoformat() if self._started_at else None, + "error_count": len(self._errors), + "last_error": { + "message": self.last_error.message, + "timestamp": self.last_error.timestamp.isoformat(), + "traceback": self.last_error.traceback, + } + if self.last_error + else None, + "unified_webhook": False, + "meta": meta_info, + } + async def terminate(self) -> None: """终止平台运行""" self._running = False diff --git a/astrbot/core/platform/sources/cli/cli_event.py b/astrbot/core/platform/sources/cli/cli_event.py index a63e2b5378..5fc82e4ed1 100644 --- a/astrbot/core/platform/sources/cli/cli_event.py +++ b/astrbot/core/platform/sources/cli/cli_event.py @@ -6,6 +6,7 @@ """ import asyncio +from collections.abc import AsyncGenerator from typing import Any from astrbot import logger @@ -21,11 +22,9 @@ class CLIMessageEvent(AstrMessageEvent): """CLI消息事件 处理命令行模拟器的消息事件。 + Socket模式下收集管道中所有send()调用的消息，在管道完成(finalize)后统一返回。 """ - # 延迟配置 - INITIAL_DELAY = 5.0 # 首次发送延迟 - EXTENDED_DELAY = 10.0 # 后续发送延迟 MAX_BUFFER_SIZE = 100 # 缓冲区最大消息组件数 def __init__( @@ -48,29 +47,21 @@ def __init__( self.output_queue = output_queue self.response_future = response_future - # 多次回复收集 + # 多次回复收集（Socket模式） self.send_buffer = None - self._response_delay_task = None - self._response_delay = self.INITIAL_DELAY async def send(self, message_chain: MessageChain) -> dict[str, Any]: """发送消息到CLI""" - # 调用父类方法以设置 _has_send_oper 标志 - # 这告诉 ProcessStage 已经有发送操作，避免触发 LLM await super().send(message_chain) - # Socket模式：收集多次回复 + # Socket模式：收集所有回复到buffer，等待finalize()统一返回 if self.response_future is not None and not self.response_future.done(): - # 使用 ImageProcessor 预处理图片（避免临时文件被删除） ImageProcessor.preprocess_chain(message_chain) - # 收集多次回复到buffer if not self.send_buffer: self.send_buffer = message_chain - self._response_delay = self.INITIAL_DELAY logger.debug("[CLI] First send: buffer initialized") else: - # 检查缓冲区大小限制 current_size = len(self.send_buffer.chain) new_size = len(message_chain.chain) if current_size + new_size > self.MAX_BUFFER_SIZE: @@ -80,47 +71,61 @@ async def send(self, message_chain: MessageChain) -> dict[str, Any]: new_size, self.MAX_BUFFER_SIZE, ) - # 只添加能容纳的部分 available = self.MAX_BUFFER_SIZE - current_size if available > 0: self.send_buffer.chain.extend(message_chain.chain[:available]) else: self.send_buffer.chain.extend(message_chain.chain) - self._response_delay = self.EXTENDED_DELAY logger.debug( "[CLI] Appended to buffer, total: %d", len(self.send_buffer.chain) ) - - # 重置延迟任务 - if self._response_delay_task and not self._response_delay_task.done(): - self._response_delay_task.cancel() - - self._response_delay_task = asyncio.create_task(self._delayed_response()) else: - # 其他模式：直接放入输出队列 + # 非Socket模式或future已完成：直接放入输出队列 await self.output_queue.put(message_chain) return {"success": True} + async def send_streaming( + self, + generator: AsyncGenerator[MessageChain, None], + use_fallback: bool = False, + ) -> None: + """处理流式LLM响应 + + CLI不支持真正的流式输出，采用收集后一次性发送的策略。 + 与aiocqhttp的非fallback模式一致。 + """ + buffer = None + async for chain in generator: + if not buffer: + buffer = chain + else: + buffer.chain.extend(chain.chain) + + if not buffer: + return + + buffer.squash_plain() + await self.send(buffer) + await super().send_streaming(generator, use_fallback) + async def reply(self, message_chain: MessageChain) -> dict[str, Any]: """回复消息""" return await self.send(message_chain) - async def _delayed_response(self) -> None: - """延迟响应：收集所有回复后统一返回""" - try: - await asyncio.sleep(self._response_delay) + async def finalize(self) -> None: + """管道完成后调用，将收集的所有回复统一返回给Socket客户端。 - if self.response_future and not self.response_future.done(): + 由PipelineScheduler.execute()在所有阶段执行完毕后调用。 + """ + if self.response_future and not self.response_future.done(): + if self.send_buffer: self.response_future.set_result(self.send_buffer) logger.debug( - "[CLI] Delayed response set, %d components", + "[CLI] Pipeline done, response set with %d components", len(self.send_buffer.chain), ) - - except asyncio.CancelledError: - pass - except Exception as e: - logger.error("[CLI] Delayed response error: %s", e) - if self.response_future and not self.response_future.done(): - self.response_future.set_exception(e) + else: + # 管道完成但没有任何发送操作（如被白名单/频率限制拦截） + self.response_future.set_result(None) + logger.debug("[CLI] Pipeline done, no response to send") diff --git a/astrbot/core/platform/sources/cli/handlers/socket_handler.py b/astrbot/core/platform/sources/cli/handlers/socket_handler.py index 73ade8ffc2..4d1ee7507d 100644 --- a/astrbot/core/platform/sources/cli/handlers/socket_handler.py +++ b/astrbot/core/platform/sources/cli/handlers/socket_handler.py @@ -12,6 +12,7 @@ from typing import TYPE_CHECKING from astrbot import logger +from astrbot.core.message.message_event_result import MessageChain from ..interfaces import IHandler, IMessageConverter, ISessionManager, ITokenValidator from ..message.response_builder import ResponseBuilder @@ -34,7 +35,7 @@ class SocketClientHandler: RECV_BUFFER_SIZE = 4096 MAX_REQUEST_SIZE = 1024 * 1024 # 1MB 最大请求大小 - RESPONSE_TIMEOUT = 30.0 + RESPONSE_TIMEOUT = 120.0 def __init__( self, @@ -181,14 +182,13 @@ async def _process_message(self, message_text: str, request_id: str) -> str: message_chain = await asyncio.wait_for( response_future, timeout=self.RESPONSE_TIMEOUT ) + if message_chain is None: + # 管道完成但没有产生任何回复（被白名单/频率限制等拦截） + return ResponseBuilder.build_success( + MessageChain([]), request_id + ) return ResponseBuilder.build_success(message_chain, request_id) except asyncio.TimeoutError: - # 超时时取消延迟响应任务，防止资源泄露 - if ( - hasattr(message_event, "_response_delay_task") - and message_event._response_delay_task - ): - message_event._response_delay_task.cancel() return ResponseBuilder.build_error("Request timeout", request_id, "TIMEOUT") async def _get_logs(self, request: dict, request_id: str) -> str: diff --git a/astrbot/core/platform/sources/cli/message/converter.py b/astrbot/core/platform/sources/cli/message/converter.py index 7cf7a296fe..aaddc5bfa4 100644 --- a/astrbot/core/platform/sources/cli/message/converter.py +++ b/astrbot/core/platform/sources/cli/message/converter.py @@ -71,4 +71,6 @@ def convert( nickname=self.user_nickname, ) + message.raw_message = None + return message diff --git a/astrbot/dashboard/routes/platform.py b/astrbot/dashboard/routes/platform.py index 874bc19db7..d4634c7c5f 100644 --- a/astrbot/dashboard/routes/platform.py +++ b/astrbot/dashboard/routes/platform.py @@ -81,7 +81,9 @@ def _find_platform_by_uuid(self, webhook_uuid: str) -> Platform | None: 平台适配器实例，未找到则返回 None """ for platform in self.platform_manager.platform_insts: - if platform.config.get("webhook_uuid") == webhook_uuid: + config = platform.config + uuid_val = config.get("webhook_uuid") if isinstance(config, dict) else getattr(config, "webhook_uuid", None) + if uuid_val == webhook_uuid: if platform.unified_webhook(): return platform return None From 50ccc88a21866862551029111cb5961c78a7eb24 Mon Sep 17 00:00:00 2001 From: YukiRa1n <167516635+YukiRa1n@users.noreply.github.com> Date: Thu, 12 Feb 2026 12:23:58 +0800 Subject: [PATCH 29/39] =?UTF-8?q?fix(cli):=20=E6=94=AF=E6=8C=81=E5=85=A8?= =?UTF-8?q?=E5=B1=80=E8=B0=83=E7=94=A8=20run/restart=EF=BC=8Crun=20?= =?UTF-8?q?=E9=BB=98=E8=AE=A4=E5=BD=93=E5=89=8D=E7=AA=97=E5=8F=A3?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - get_astrbot_root: 支持环境变量 ASTRBOT_ROOT 和向上查找 .astrbot 标记 - run: 默认当前窗口运行，--new-window 才开新窗口 - restart: 保持默认新窗口行为不变 --- astrbot/cli/commands/cmd_run.py | 16 ++++++++-------- astrbot/cli/utils/basic.py | 26 ++++++++++++++++++++++++-- 2 files changed, 32 insertions(+), 10 deletions(-) diff --git a/astrbot/cli/commands/cmd_run.py b/astrbot/cli/commands/cmd_run.py index 2ca9e3ee4d..cb6dc82a47 100644 --- a/astrbot/cli/commands/cmd_run.py +++ b/astrbot/cli/commands/cmd_run.py @@ -113,13 +113,14 @@ def launch_in_new_window( @click.option("--reload", "-r", is_flag=True, help="插件自动重载") @click.option("--port", "-p", help="Astrbot Dashboard端口", required=False, type=str) @click.option( - "--no-window", + "--new-window", is_flag=True, - help="在当前窗口运行（仅 Windows）", + help="在新窗口启动（仅 Windows/macOS/Linux 桌面环境）", ) +@click.option("--no-window", is_flag=True, hidden=True, help="内部使用：防止递归开窗口") @click.command() -def run(reload: bool, port: str, no_window: bool) -> None: - """运行 AstrBot（Windows 默认新窗口，Linux/macOS 当前窗口）""" +def run(reload: bool, port: str, new_window: bool, no_window: bool) -> None: + """运行 AstrBot（默认当前窗口）""" os.environ["ASTRBOT_CLI"] = "1" astrbot_root = get_astrbot_root() @@ -128,14 +129,13 @@ def run(reload: bool, port: str, no_window: bool) -> None: f"{astrbot_root}不是有效的 AstrBot 根目录，如需初始化请使用 astrbot init", ) - # Windows: 默认在新窗口启动（除非指定 --no-window） - # Linux/macOS: 始终在当前窗口运行 - if sys.platform == "win32" and not no_window: + # 仅在明确指定 --new-window 且非内部调用时才在新窗口启动 + if new_window and not no_window: launch_in_new_window(astrbot_root, reload, port) click.echo("[OK] AstrBot 已在新窗口中启动") return - # 在当前窗口运行（Linux/macOS 默认，Windows 指定 --no-window） + # 默认在当前窗口运行 try: os.environ["ASTRBOT_ROOT"] = str(astrbot_root) sys.path.insert(0, str(astrbot_root)) diff --git a/astrbot/cli/utils/basic.py b/astrbot/cli/utils/basic.py index 5dbe290065..8d193ed0af 100644 --- a/astrbot/cli/utils/basic.py +++ b/astrbot/cli/utils/basic.py @@ -15,8 +15,30 @@ def check_astrbot_root(path: str | Path) -> bool: def get_astrbot_root() -> Path: - """获取Astrbot根目录路径""" - return Path.cwd() + """获取 AstrBot 根目录路径 + + 查找顺序： + 1. 环境变量 ASTRBOT_ROOT + 2. 从当前目录向上查找包含 .astrbot 标记的目录 + 3. 回退到当前工作目录 + """ + # 1. 环境变量 + import os + + env_root = os.environ.get("ASTRBOT_ROOT") + if env_root: + p = Path(env_root) + if check_astrbot_root(p): + return p + + # 2. 向上查找 .astrbot 标记 + current = Path.cwd() + for parent in [current, *current.parents]: + if (parent / ".astrbot").exists(): + return parent + + # 3. 回退到当前目录 + return current async def check_dashboard(astrbot_root: Path) -> None: From 0579643f452ca616c44db868a79eb021a003e717 Mon Sep 17 00:00:00 2001 From: YukiRa1n <167516635+YukiRa1n@users.noreply.github.com> Date: Thu, 12 Feb 2026 13:14:29 +0800 Subject: [PATCH 30/39] =?UTF-8?q?fix(cli):=20=E4=BF=AE=E5=A4=8D=E5=85=A8?= =?UTF-8?q?=E5=B1=80=E8=B0=83=E7=94=A8=E6=97=B6=E8=B7=AF=E5=BE=84=E5=AE=9A?= =?UTF-8?q?=E4=BD=8D=E9=94=99=E8=AF=AF?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - get_astrbot_root() 优先通过 __file__ 定位源码目录，避免匹配到错误的 .astrbot 标记 - get_temp_path() 增加 __file__ 回退，硬编码 /tmp 改为 tempfile.gettempdir() 兼容 Windows - launch_in_new_window() 用 CREATE_NEW_CONSOLE 替代 Start-Process powershell，修复环境变量传递 - taskkill 加 /T 参数杀进程树，避免子进程残留 --- astrbot/cli/client/__main__.py | 11 ++++++++++- astrbot/cli/commands/cmd_restart.py | 12 ++++++------ astrbot/cli/utils/basic.py | 15 +++++++++++---- 3 files changed, 27 insertions(+), 11 deletions(-) diff --git a/astrbot/cli/client/__main__.py b/astrbot/cli/client/__main__.py index 998f76bbfd..0004be38ac 100644 --- a/astrbot/cli/client/__main__.py +++ b/astrbot/cli/client/__main__.py @@ -74,8 +74,17 @@ def get_temp_path() -> str: # 优先使用环境变量 if root := os.environ.get("ASTRBOT_ROOT"): return os.path.join(root, "data", "temp") + # 通过源码目录定位 + source_root = os.path.realpath( + os.path.join(os.path.dirname(os.path.abspath(__file__)), "../../..") + ) + temp_dir = os.path.join(source_root, "data", "temp") + if os.path.isdir(os.path.join(source_root, "data")): + return temp_dir # 默认使用系统临时目录 - return "/tmp" + import tempfile + + return tempfile.gettempdir() def load_auth_token() -> str: diff --git a/astrbot/cli/commands/cmd_restart.py b/astrbot/cli/commands/cmd_restart.py index e0d10d802e..d498e0f9c1 100644 --- a/astrbot/cli/commands/cmd_restart.py +++ b/astrbot/cli/commands/cmd_restart.py @@ -57,13 +57,13 @@ def launch_in_new_window( env["ASTRBOT_RELOAD"] = "1" if sys.platform == "win32": - # Windows: 使用 powershell 开新窗口 - cmd_str = " ".join(f'"{c}"' if " " in str(c) else str(c) for c in cmd) - ps_script = f'Start-Process powershell -ArgumentList "-NoExit", "-Command", "cd {astrbot_root}; {cmd_str}" -WindowStyle Normal' + # Windows: 使用 CREATE_NEW_CONSOLE 在新窗口启动，环境变量通过 env 直接传递 + CREATE_NEW_CONSOLE = 0x00000010 subprocess.Popen( - ["powershell", "-Command", ps_script], + cmd, env=env, - shell=False, + cwd=str(astrbot_root), + creationflags=CREATE_NEW_CONSOLE, ) elif sys.platform == "darwin": # macOS: 使用 osascript 打开新的 Terminal 窗口 @@ -166,7 +166,7 @@ def find_and_kill_astrbot_processes(astrbot_root: Path) -> bool: cmdline_lower = cmdline.lower() if "astrbot" in cmdline_lower or "astrbot.exe" in cmdline_lower: subprocess.run( - ["taskkill", "/F", "/PID", str(pid)], + ["taskkill", "/F", "/T", "/PID", str(pid)], capture_output=True, timeout=5, ) diff --git a/astrbot/cli/utils/basic.py b/astrbot/cli/utils/basic.py index 8d193ed0af..503a9713f8 100644 --- a/astrbot/cli/utils/basic.py +++ b/astrbot/cli/utils/basic.py @@ -19,8 +19,9 @@ def get_astrbot_root() -> Path: 查找顺序： 1. 环境变量 ASTRBOT_ROOT - 2. 从当前目录向上查找包含 .astrbot 标记的目录 - 3. 回退到当前工作目录 + 2. 通过包安装路径定位（editable install / 源码目录） + 3. 从当前目录向上查找包含 .astrbot 标记的目录 + 4. 回退到当前工作目录 """ # 1. 环境变量 import os @@ -31,13 +32,19 @@ def get_astrbot_root() -> Path: if check_astrbot_root(p): return p - # 2. 向上查找 .astrbot 标记 + # 2. 通过包安装路径定位（editable install 场景） + # __file__ 在 astrbot/cli/utils/basic.py，向上 4 级到达项目根目录 + source_root = Path(__file__).resolve().parent.parent.parent.parent + if check_astrbot_root(source_root): + return source_root + + # 3. 向上查找 .astrbot 标记 current = Path.cwd() for parent in [current, *current.parents]: if (parent / ".astrbot").exists(): return parent - # 3. 回退到当前目录 + # 4. 回退到当前目录 return current From f31f64670c351547d0b6a3ecc0e4b58cdf1f4f3a Mon Sep 17 00:00:00 2001 From: YukiRa1n <167516635+YukiRa1n@users.noreply.github.com> Date: Thu, 19 Feb 2026 16:00:08 +0800 Subject: [PATCH 31/39] refactor(cli): modularize CLI client and add rich command set MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - Extract connection.py, output.py from monolithic __main__.py (708→154 lines) - Add command modules: conv, plugin, provider, debug, interactive, batch - Add 16 top-level commands covering session mgmt, plugin mgmt, LLM config, debug tools - Add interactive REPL mode (astr -i) with command history - Maintain full backward compatibility (astr 你好, astr --log, pipe input) - Redesign --help to show all commands/subcommands in one view - Add 97 unit tests (connection, commands, interactive) + 36 E2E tests --- astrbot/cli/client/__main__.py | 699 +++------------------ astrbot/cli/client/commands/__init__.py | 93 +++ astrbot/cli/client/commands/conv.py | 73 +++ astrbot/cli/client/commands/debug.py | 135 ++++ astrbot/cli/client/commands/interactive.py | 103 +++ astrbot/cli/client/commands/log.py | 131 ++++ astrbot/cli/client/commands/plugin.py | 47 ++ astrbot/cli/client/commands/provider.py | 55 ++ astrbot/cli/client/commands/send.py | 47 ++ astrbot/cli/client/connection.py | 304 +++++++++ astrbot/cli/client/output.py | 84 +++ tests/test_cli/test_client_commands.py | 559 ++++++++++++++++ tests/test_cli/test_client_connection.py | 267 ++++++++ tests/test_cli/test_client_e2e.py | 618 ++++++++++++++++++ tests/test_cli/test_client_interactive.py | 206 ++++++ 15 files changed, 2800 insertions(+), 621 deletions(-) create mode 100644 astrbot/cli/client/commands/__init__.py create mode 100644 astrbot/cli/client/commands/conv.py create mode 100644 astrbot/cli/client/commands/debug.py create mode 100644 astrbot/cli/client/commands/interactive.py create mode 100644 astrbot/cli/client/commands/log.py create mode 100644 astrbot/cli/client/commands/plugin.py create mode 100644 astrbot/cli/client/commands/provider.py create mode 100644 astrbot/cli/client/commands/send.py create mode 100644 astrbot/cli/client/connection.py create mode 100644 astrbot/cli/client/output.py create mode 100644 tests/test_cli/test_client_commands.py create mode 100644 tests/test_cli/test_client_connection.py create mode 100644 tests/test_cli/test_client_e2e.py create mode 100644 tests/test_cli/test_client_interactive.py diff --git a/astrbot/cli/client/__main__.py b/astrbot/cli/client/__main__.py index 0004be38ac..f5656c98e3 100644 --- a/astrbot/cli/client/__main__.py +++ b/astrbot/cli/client/__main__.py @@ -25,445 +25,80 @@ root.removeHandler(handler) import io # noqa: E402 -import json # noqa: E402 -import os # noqa: E402 -import re # noqa: E402 -import socket # noqa: E402 import sys # noqa: E402 -import uuid # noqa: E402 import click # noqa: E402 # 仅使用标准库导入，不导入astrbot框架 -# Windows UTF-8 输出支持 -if sys.platform == "win32": - # 设置stdout/stderr为UTF-8编码 +# Windows UTF-8 输出支持（仅在非测试环境下替换，避免与 pytest capture 冲突） +if sys.platform == "win32" and "pytest" not in sys.modules: sys.stdout = io.TextIOWrapper(sys.stdout.buffer, encoding="utf-8", errors="replace") sys.stderr = io.TextIOWrapper(sys.stderr.buffer, encoding="utf-8", errors="replace") -def get_data_path() -> str: - """获取数据目录路径 - - 优先级： - 1. 环境变量 ASTRBOT_ROOT - 2. 源码安装目录（通过 __file__ 获取） - 3. 当前工作目录 - """ - # 优先使用环境变量 - if root := os.environ.get("ASTRBOT_ROOT"): - return os.path.join(root, "data") - - # 获取源码安装目录（__main__.py 在 astrbot/cli/client/） - # 向上 3 级到达根目录 - source_root = os.path.realpath( - os.path.join(os.path.dirname(os.path.abspath(__file__)), "../../..") - ) - data_dir = os.path.join(source_root, "data") - - # 如果源码目录下存在 data 目录，使用它 - if os.path.exists(data_dir): - return data_dir - - # 回退到当前工作目录 - return os.path.join(os.path.realpath(os.getcwd()), "data") - - -def get_temp_path() -> str: - """获取临时目录路径,兼容容器和非容器环境""" - # 优先使用环境变量 - if root := os.environ.get("ASTRBOT_ROOT"): - return os.path.join(root, "data", "temp") - # 通过源码目录定位 - source_root = os.path.realpath( - os.path.join(os.path.dirname(os.path.abspath(__file__)), "../../..") - ) - temp_dir = os.path.join(source_root, "data", "temp") - if os.path.isdir(os.path.join(source_root, "data")): - return temp_dir - # 默认使用系统临时目录 - import tempfile - - return tempfile.gettempdir() - - -def load_auth_token() -> str: - """从密钥文件加载认证token - - Returns: - token字符串,如果文件不存在则返回空字符串 - """ - token_file = os.path.join(get_data_path(), ".cli_token") - try: - with open(token_file, encoding="utf-8") as f: - return f.read().strip() - except FileNotFoundError: - return "" - except Exception: - return "" - - -def load_connection_info(data_dir: str) -> dict | None: - """加载连接信息 - - 从.cli_connection文件读取Socket连接信息 - - Args: - data_dir: 数据目录路径 - - Returns: - 连接信息字典，如果文件不存在则返回None - - Example: - Unix Socket: {"type": "unix", "path": "/tmp/astrbot.sock"} - TCP Socket: {"type": "tcp", "host": "127.0.0.1", "port": 12345} - """ - connection_file = os.path.join(data_dir, ".cli_connection") - try: - with open(connection_file, encoding="utf-8") as f: - connection_info = json.load(f) - return connection_info - except FileNotFoundError: - return None - except json.JSONDecodeError as e: - print( - f"[ERROR] Invalid JSON in connection file: {connection_file}", - file=sys.stderr, - ) - print(f"[ERROR] {e}", file=sys.stderr) - return None - except Exception as e: - print( - f"[ERROR] Failed to load connection info: {e}", - file=sys.stderr, - ) - return None - - -def connect_to_server(connection_info: dict, timeout: float = 30.0) -> socket.socket: - """连接到服务器 - - 根据连接信息类型选择Unix Socket或TCP Socket连接 - - Args: - connection_info: 连接信息字典 - timeout: 超时时间（秒） - - Returns: - socket连接对象 - - Raises: - ValueError: 无效的连接类型 - ConnectionError: 连接失败 - """ - socket_type = connection_info.get("type") - - if socket_type == "unix": - # Unix Socket连接 - socket_path = connection_info.get("path") - if not socket_path: - raise ValueError("Unix socket path is missing in connection info") - - try: - client_socket = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM) - client_socket.settimeout(timeout) - client_socket.connect(socket_path) - return client_socket - except FileNotFoundError: - raise ConnectionError( - f"Socket file not found: {socket_path}. Is AstrBot running?" - ) - except ConnectionRefusedError: - raise ConnectionError( - "Connection refused. Is AstrBot running in socket mode?" - ) - except Exception as e: - raise ConnectionError(f"Unix socket connection error: {e}") - - elif socket_type == "tcp": - # TCP Socket连接 - host = connection_info.get("host") - port = connection_info.get("port") - if not host or not port: - raise ValueError("TCP host or port is missing in connection info") - - try: - client_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM) - client_socket.settimeout(timeout) - client_socket.connect((host, port)) - return client_socket - except ConnectionRefusedError: - raise ConnectionError( - f"Connection refused to {host}:{port}. Is AstrBot running?" - ) - except TimeoutError: - raise ConnectionError(f"Connection timeout to {host}:{port}") - except Exception as e: - raise ConnectionError(f"TCP socket connection error: {e}") - - else: - raise ValueError( - f"Invalid socket type: {socket_type}. Expected 'unix' or 'tcp'" - ) - - -def send_message( - message: str, socket_path: str | None = None, timeout: float = 30.0 -) -> dict: - """发送消息到AstrBot并获取响应 - - 支持自动检测连接类型（Unix Socket或TCP Socket） - - Args: - message: 要发送的消息 - socket_path: Unix socket路径(仅用于向后兼容，优先使用.cli_connection) - timeout: 超时时间（秒） - - Returns: - 响应字典 - """ - data_dir = get_data_path() - - # 加载认证token - auth_token = load_auth_token() - - # 创建请求 - request = {"message": message, "request_id": str(uuid.uuid4())} - - # 如果token存在,添加到请求中 - if auth_token: - request["auth_token"] = auth_token - - # 尝试加载连接信息 - connection_info = load_connection_info(data_dir) - - # 连接到服务器 - try: - if connection_info is not None: - # 使用连接信息文件 - client_socket = connect_to_server(connection_info, timeout) - else: - # 向后兼容：使用默认Unix Socket路径 - if socket_path is None: - socket_path = os.path.join(get_temp_path(), "astrbot.sock") - - fallback_info = {"type": "unix", "path": socket_path} - client_socket = connect_to_server(fallback_info, timeout) - - except (ValueError, ConnectionError) as e: - return {"status": "error", "error": str(e)} - except Exception as e: - return {"status": "error", "error": f"Connection error: {e}"} - - try: - # 发送请求 - request_data = json.dumps(request, ensure_ascii=False).encode("utf-8") - client_socket.sendall(request_data) - - # 接收响应（循环接收所有数据，支持大响应如base64图片） - response_data = b"" - while True: - chunk = client_socket.recv(4096) - if not chunk: - break - response_data += chunk - # 尝试解析JSON，如果成功说明接收完整 - try: - response = json.loads(response_data.decode("utf-8", errors="replace")) - return response - except json.JSONDecodeError: - # JSON不完整，继续接收 - continue - - # 如果循环结束仍未成功解析，尝试最后一次 - response = json.loads(response_data.decode("utf-8", errors="replace")) - return response - - except TimeoutError: - return {"status": "error", "error": "Request timeout"} - except Exception as e: - return {"status": "error", "error": f"Communication error: {e}"} - finally: - client_socket.close() - - -def get_logs( - socket_path: str | None = None, - timeout: float = 30.0, - lines: int = 100, - level: str = "", - pattern: str = "", - use_regex: bool = False, -) -> dict: - """获取AstrBot日志 - - Args: - socket_path: Socket路径 - timeout: 超时时间 - lines: 返回的日志行数 - level: 日志级别过滤 - pattern: 模式过滤 - use_regex: 是否使用正则表达式 - - Returns: - 响应字典 - """ - data_dir = get_data_path() - - # 加载认证token - auth_token = load_auth_token() - - # 创建请求 - request = { - "action": "get_logs", - "request_id": str(uuid.uuid4()), - "lines": lines, - "level": level, - "pattern": pattern, - "regex": use_regex, - } - - # 添加token - if auth_token: - request["auth_token"] = auth_token - - # 加载连接信息 - connection_info = load_connection_info(data_dir) - - # 连接到服务器 - try: - if connection_info is not None: - client_socket = connect_to_server(connection_info, timeout) - else: - if socket_path is None: - socket_path = os.path.join(get_temp_path(), "astrbot.sock") - fallback_info = {"type": "unix", "path": socket_path} - client_socket = connect_to_server(fallback_info, timeout) - - except (ValueError, ConnectionError) as e: - return {"status": "error", "error": str(e)} - except Exception as e: - return {"status": "error", "error": f"Connection error: {e}"} - - try: - # 发送请求 - request_data = json.dumps(request, ensure_ascii=False).encode("utf-8") - client_socket.sendall(request_data) - - # 接收响应 - response_data = b"" - while True: - chunk = client_socket.recv(4096) - if not chunk: - break - response_data += chunk - try: - response = json.loads(response_data.decode("utf-8", errors="replace")) - return response - except json.JSONDecodeError: - continue - - response = json.loads(response_data.decode("utf-8", errors="replace")) - return response - - except TimeoutError: - return {"status": "error", "error": "Request timeout"} - except Exception as e: - return {"status": "error", "error": f"Communication error: {e}"} - finally: - client_socket.close() - - -def format_response(response: dict) -> str: - """格式化响应输出 - - 处理： - 1. 分段回复（每行一句） - 2. 图片占位符 - - Args: - response: 响应字典 - - Returns: - 格式化后的字符串 - """ - if response.get("status") != "success": - return "" - - # 获取文本响应 - text = response.get("response", "") - - # 获取图片数量 - images = response.get("images", []) - image_count = len(images) - - # 处理分段：按换行符分割，然后每行单独输出 - lines = text.split("\n") - - # 如果有图片，在末尾添加图片占位符 - if image_count > 0: - if image_count == 1: - lines.append("[图片]") - else: - lines.append(f"[{image_count}张图片]") - - # 用换行符连接所有行 - return "\n".join(lines) - - -def fix_git_bash_path(message: str) -> str: - """修复 Git Bash 路径转换问题 - - Git Bash (MSYS2) 会把 /plugin ls 转换为 C:/Program Files/Git/plugin ls - 检测并还原原始命令 - - Args: - message: 被转换后的消息 - - Returns: - 修复后的消息 - """ - # 检测是否是 Git Bash 转换的路径 - # 模式: :/Program Files/Git/ - pattern = r"[A-Z]:/(Program Files/Git|msys[0-9]+/[^/]+)/([^/]+)" - match = re.match(pattern, message) - - if match: - # 提取原始命令 - command = match.group(2) - # 获取剩余部分 - rest = message[match.end():].lstrip() - if rest: - return f"/{command} {rest}" - return f"/{command}" - - return message - - -EPILOG = """使用示例: - 发送消息: - astr 你好 发送消息给 AstrBot - astr send 你好 同上（显式子命令） - astr send /help 查看内置命令帮助 - echo "你好" | astr 从标准输入读取 - - 获取日志: - astr log 获取最近 100 行日志（直接读取文件） - astr --log 同上（兼容旧用法） - astr log --lines 50 获取最近 50 行 - astr log --level ERROR 只显示 ERROR 级别 - astr log --pattern "CLI" 只显示包含 "CLI" 的日志 - astr log --pattern "ERRO|WARN" --regex 使用正则表达式匹配 - astr log --socket 通过 Socket 连接 AstrBot 获取 - - 高级选项: - astr -j "测试" 输出原始 JSON 响应 - astr -t 60 "长时间任务" 设置超时时间为 60 秒 - -连接说明: - 自动从 data/.cli_connection 检测连接类型（Unix Socket 或 TCP） - Token 自动从 data/.cli_token 读取 - 需在 AstrBot 根目录下运行，或设置 ASTRBOT_ROOT 环境变量 +EPILOG = """ +命令总览 (所有命令均支持 -j/--json 输出原始 JSON): +━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ + + [发送消息] + astr 直接发送消息（隐式调用 send） + astr send 显式发送消息给 AstrBot + astr send -t 60 设置超时（秒），默认 30 + echo "msg" | astr 从管道读取消息 + + [会话管理] astr conv <子命令> + astr conv ls [page] 列出所有对话（可翻页） + astr conv new 创建新对话并切换到该对话 + astr conv switch 按序号切换对话（序号见 conv ls） + astr conv del 删除当前对话 + astr conv rename 重命名当前对话 + astr conv reset 清除当前对话的 LLM 上下文 + astr conv history [page] 查看当前对话的聊天记录 + + [插件管理] astr plugin <子命令> + astr plugin ls 列出已安装插件及状态 + astr plugin on 启用指定插件 + astr plugin off 禁用指定插件 + astr plugin help [name] 查看插件帮助（省略 name 则查看全部） + + [LLM 配置] + astr provider [index] 查看 Provider 列表 / 按序号切换 + astr model [index|name] 查看模型列表 / 按序号或名称切换 + astr key [index] 查看 API Key 列表 / 按序号切换 + + [快捷命令] + astr help 查看 AstrBot 服务端内置指令帮助 + astr sid 查看当前会话 ID 和管理员 ID + astr t2i 开关文字转图片（会话级别） + astr tts 开关文字转语音（会话级别） + + [日志查看] + astr log 读取最近 100 行日志（直接读文件） + astr log --lines 50 指定行数 + astr log --level ERROR 按级别过滤 (DEBUG/INFO/WARNING/ERROR) + astr log --pattern "关键词" 按关键词过滤（--regex 启用正则） + astr log --socket 通过 Socket 从服务端获取日志 + + [调试工具] + astr ping [-c N] 测试连通性和延迟（-c 指定次数） + astr status 查看连接配置、Token、服务状态 + astr test echo 发送消息并查看完整回环响应 + astr test plugin 测试插件命令（发送 / ） + 例: astr test plugin probe cpu + → 实际发送 /probe cpu + + [交互模式] + astr interactive 进入 REPL 模式（支持命令历史） + astr -i 同上（快捷方式） + + [批量执行] + astr batch 从文件逐行读取并执行命令 + （# 开头为注释，空行跳过） + +兼容旧用法: astr --log = astr log | astr -j "msg" = astr send -j "msg" + +连接: 自动读取 data/.cli_connection 和 data/.cli_token + 需在 AstrBot 根目录运行，或设置 ASTRBOT_ROOT 环境变量 """ @@ -480,6 +115,8 @@ def format_epilog(self, ctx: click.Context, formatter: click.HelpFormatter) -> N _send_opts = {"-j", "--json", "-t", "--timeout", "-s", "--socket"} # --log 旧用法映射到 log 子命令 _log_flag = {"--log"} + # -i 快捷方式映射到 interactive 子命令 + _interactive_flag = {"-i"} def parse_args(self, ctx: click.Context, args: list[str]) -> list[str]: if args: @@ -487,6 +124,9 @@ def parse_args(self, ctx: click.Context, args: list[str]) -> list[str]: if first in self._log_flag: # astr --log ... → astr log ... args = ["log"] + args[1:] + elif first in self._interactive_flag: + # astr -i → astr interactive + args = ["interactive"] + args[1:] elif first not in self.commands: if not first.startswith("-") or first in self._send_opts: # astr 你好 / astr -j "你好" → astr send ... @@ -501,206 +141,23 @@ def parse_args(self, ctx: click.Context, args: list[str]) -> list[str]: ) @click.pass_context def main(ctx: click.Context) -> None: - """AstrBot CLI Client""" + """AstrBot CLI Client - 与 AstrBot 交互的命令行工具""" if ctx.invoked_subcommand is None: # 无子命令时，检查 stdin 是否有管道输入 if not sys.stdin.isatty(): message = sys.stdin.read().strip() if message: - _do_send(message, None, 30.0, False) + from .commands.send import do_send + + do_send(message, None, 30.0, False) return click.echo(ctx.get_help()) -@main.command(help="发送消息给 AstrBot") -@click.argument("message", nargs=-1) -@click.option("-s", "--socket", "socket_path", default=None, help="Unix socket 路径") -@click.option("-t", "--timeout", default=30.0, type=float, help="超时时间（秒）") -@click.option("-j", "--json", "use_json", is_flag=True, help="输出原始 JSON 响应") -def send( - message: tuple[str, ...], socket_path: str | None, timeout: float, use_json: bool -) -> None: - """发送消息给 AstrBot - - \b - 示例: - astr send 你好 - astr send /help - astr send plugin ls - echo "你好" | astr send - """ - if message: - msg = " ".join(message) - msg = fix_git_bash_path(msg) - elif not sys.stdin.isatty(): - msg = sys.stdin.read().strip() - else: - click.echo("Error: 请提供消息内容", err=True) - raise SystemExit(1) - - if not msg: - click.echo("Error: 消息内容为空", err=True) - raise SystemExit(1) - - _do_send(msg, socket_path, timeout, use_json) - - -def _do_send(msg: str, socket_path: str | None, timeout: float, use_json: bool) -> None: - """执行消息发送并输出结果""" - response = send_message(msg, socket_path, timeout) - _output_response(response, use_json) - - -@main.command(help="获取 AstrBot 日志") -@click.option( - "--lines", default=100, type=int, help="返回的日志行数（默认 100，最大 1000）" -) -@click.option( - "--level", default="", help="按级别过滤 (DEBUG/INFO/WARNING/ERROR/CRITICAL)" -) -@click.option("--pattern", default="", help="按模式过滤（子串匹配）") -@click.option("--regex", is_flag=True, help="使用正则表达式匹配 pattern") -@click.option( - "--socket", - "use_socket", - is_flag=True, - help="通过 Socket 连接 AstrBot 获取日志（需要 AstrBot 运行）", -) -@click.option( - "-t", "--timeout", default=30.0, type=float, help="超时时间（仅 Socket 模式）" -) -def log( - lines: int, - level: str, - pattern: str, - regex: bool, - use_socket: bool, - timeout: float, -) -> None: - """获取 AstrBot 日志 - - \b - 示例: - astr log # 直接读取日志文件（默认） - astr log --lines 50 # 获取最近 50 行 - astr log --level ERROR # 只显示 ERROR 级别 - astr log --pattern "plugin" # 匹配包含 "plugin" 的日志 - astr log --pattern "ERRO|WARN" --regex # 使用正则表达式 - astr log --socket # 通过 Socket 连接 AstrBot 获取 - """ - if use_socket: - # 通过 Socket 获取日志 - response = get_logs(None, timeout, lines, level, pattern, regex) - # 输出响应（复用 _output_response，但不需要 use_json 参数） - if response.get("status") == "success": - formatted = response.get("response", "") - click.echo(formatted) - else: - error = response.get("error", "Unknown error") - click.echo(f"Error: {error}", err=True) - raise SystemExit(1) - else: - # 直接读取日志文件（默认） - _read_log_from_file(lines, level, pattern, regex) - - -def _output_response(response: dict, use_json: bool) -> None: - """统一输出响应""" - if use_json: - click.echo(json.dumps(response, ensure_ascii=False, indent=2)) - else: - if response.get("status") == "success": - formatted = format_response(response) - click.echo(formatted) - else: - error = response.get("error", "Unknown error") - click.echo(f"Error: {error}", err=True) - raise SystemExit(1) - - -def _read_log_from_file(lines: int, level: str, pattern: str, use_regex: bool) -> None: - """直接从日志文件读取 - - Args: - lines: 返回的日志行数 - level: 日志级别过滤 - pattern: 模式过滤 - use_regex: 是否使用正则表达式 - """ - import re - - # 日志级别映射 - LEVEL_MAP = { - "DEBUG": "DEBUG", - "INFO": "INFO", - "WARNING": "WARN", - "WARN": "WARN", - "ERROR": "ERRO", - "CRITICAL": "CRIT", - } - - # 映射级别 - level_filter = LEVEL_MAP.get(level.upper(), level.upper()) - - # 日志文件路径 - log_path = os.path.join(get_data_path(), "logs", "astrbot.log") - - if not os.path.exists(log_path): - click.echo( - f"Error: 日志文件未找到: {log_path}", - err=True, - ) - click.echo( - "提示: 请在配置中启用 log_file_enable 来记录日志到文件，或使用不带 --file 的方式连接 AstrBot", - err=True, - ) - raise SystemExit(1) - - try: - with open(log_path, encoding="utf-8", errors="ignore") as f: - all_lines = f.readlines() - - # 从末尾开始筛选 - logs = [] - for line in reversed(all_lines): - # 跳过空行 - if not line.strip(): - continue - - # 级别过滤 - if level_filter: - if not re.search(rf"\[{level_filter}\]", line): - continue - - # 模式过滤 - if pattern: - if use_regex: - try: - if not re.search(pattern, line): - continue - except re.error: - # 正则表达式错误，回退到子串匹配 - if pattern not in line: - continue - else: - if pattern not in line: - continue - - logs.append(line.rstrip()) - - if len(logs) >= lines: - break - - # 反转回来（使时间顺序正确） - logs.reverse() - - # 输出 - for log_line in logs: - click.echo(log_line) - - except OSError as e: - click.echo(f"Error: 读取日志文件失败: {e}", err=True) - raise SystemExit(1) +# 注册所有子命令 +from .commands import register_commands # noqa: E402 + +register_commands(main) if __name__ == "__main__": diff --git a/astrbot/cli/client/commands/__init__.py b/astrbot/cli/client/commands/__init__.py new file mode 100644 index 0000000000..c71931b310 --- /dev/null +++ b/astrbot/cli/client/commands/__init__.py @@ -0,0 +1,93 @@ +"""命令注册模块 - 将所有子命令注册到主 CLI group""" + +import click + +from .conv import conv +from .debug import ping, status, test +from .interactive import interactive +from .log import log +from .plugin import plugin +from .provider import key, model, provider +from .send import send + + +def register_commands(group): + """将所有子命令注册到 CLI group + + Args: + group: click.Group 实例 + """ + # 核心命令 + group.add_command(send) + group.add_command(log) + + # 会话管理 + group.add_command(conv) + + # 插件管理 + group.add_command(plugin) + + # Provider/Model/Key + group.add_command(provider) + group.add_command(model) + group.add_command(key) + + # 调试工具 + group.add_command(ping) + group.add_command(status) + group.add_command(test) + + # 交互模式 + group.add_command(interactive) + + # 快捷别名（独立命令，映射到 send /cmd） + _register_aliases(group) + + +def _register_aliases(group): + """注册快捷别名命令""" + from .. import connection, output + + @group.command(name="help", help="查看 AstrBot 内置命令帮助") + @click.option("-j", "--json", "use_json", is_flag=True, help="输出原始 JSON") + def help_cmd(use_json): + response = connection.send_message("/help") + output.output_response(response, use_json) + + @group.command(name="sid", help="查看当前会话 ID 和管理员 ID") + @click.option("-j", "--json", "use_json", is_flag=True, help="输出原始 JSON") + def sid_cmd(use_json): + response = connection.send_message("/sid") + output.output_response(response, use_json) + + @group.command(name="t2i", help="开关文字转图片（会话级别）") + @click.option("-j", "--json", "use_json", is_flag=True, help="输出原始 JSON") + def t2i_cmd(use_json): + response = connection.send_message("/t2i") + output.output_response(response, use_json) + + @group.command(name="tts", help="开关文字转语音（会话级别）") + @click.option("-j", "--json", "use_json", is_flag=True, help="输出原始 JSON") + def tts_cmd(use_json): + response = connection.send_message("/tts") + output.output_response(response, use_json) + + @group.command(name="batch", help="从文件批量执行命令") + @click.argument("file", type=click.Path(exists=True)) + @click.option("-j", "--json", "use_json", is_flag=True, help="输出原始 JSON") + def batch_cmd(file, use_json): + """从文件逐行读取并执行命令 + + \b + 示例: + astr batch commands.txt 批量执行文件中的命令 + """ + with open(file, encoding="utf-8") as f: + for line_num, line in enumerate(f, 1): + line = line.strip() + if not line or line.startswith("#"): + continue + click.echo(f"[{line_num}] > {line}") + response = connection.send_message(line) + output.output_response(response, use_json) + click.echo("") diff --git a/astrbot/cli/client/commands/conv.py b/astrbot/cli/client/commands/conv.py new file mode 100644 index 0000000000..98f44c02c0 --- /dev/null +++ b/astrbot/cli/client/commands/conv.py @@ -0,0 +1,73 @@ +"""会话管理命令组 - astr conv""" + +import click + +from ..connection import send_message +from ..output import output_response + + +@click.group(help="会话管理 (子命令: ls/new/switch/del/rename/reset/history)") +def conv() -> None: + """会话管理命令组""" + + +@conv.command(name="ls", help="列出当前会话的所有对话") +@click.argument("page", default="", required=False) +@click.option("-j", "--json", "use_json", is_flag=True, help="输出原始 JSON") +def conv_ls(page: str, use_json: bool) -> None: + """列出对话""" + cmd = "/ls" if not page else f"/ls {page}" + response = send_message(cmd) + output_response(response, use_json) + + +@conv.command(name="new", help="创建新对话") +@click.option("-j", "--json", "use_json", is_flag=True, help="输出原始 JSON") +def conv_new(use_json: bool) -> None: + """创建新对话""" + response = send_message("/new") + output_response(response, use_json) + + +@conv.command(name="switch", help="按序号切换对话") +@click.argument("index", type=int) +@click.option("-j", "--json", "use_json", is_flag=True, help="输出原始 JSON") +def conv_switch(index: int, use_json: bool) -> None: + """按序号切换对话""" + response = send_message(f"/switch {index}") + output_response(response, use_json) + + +@conv.command(name="del", help="删除当前对话") +@click.option("-j", "--json", "use_json", is_flag=True, help="输出原始 JSON") +def conv_del(use_json: bool) -> None: + """删除当前对话""" + response = send_message("/del") + output_response(response, use_json) + + +@conv.command(name="rename", help="重命名当前对话") +@click.argument("name") +@click.option("-j", "--json", "use_json", is_flag=True, help="输出原始 JSON") +def conv_rename(name: str, use_json: bool) -> None: + """重命名当前对话""" + response = send_message(f"/rename {name}") + output_response(response, use_json) + + +@conv.command(name="reset", help="重置当前 LLM 会话") +@click.option("-j", "--json", "use_json", is_flag=True, help="输出原始 JSON") +def conv_reset(use_json: bool) -> None: + """重置当前 LLM 会话""" + response = send_message("/reset") + output_response(response, use_json) + + +@conv.command(name="history", help="查看对话记录") +@click.argument("page", default="", required=False) +@click.option("-j", "--json", "use_json", is_flag=True, help="输出原始 JSON") +def conv_history(page: str, use_json: bool) -> None: + """查看对话记录""" + cmd = "/history" if not page else f"/history {page}" + response = send_message(cmd) + output_response(response, use_json) diff --git a/astrbot/cli/client/commands/debug.py b/astrbot/cli/client/commands/debug.py new file mode 100644 index 0000000000..5f279716db --- /dev/null +++ b/astrbot/cli/client/commands/debug.py @@ -0,0 +1,135 @@ +"""调试工具命令 - astr ping / astr status / astr test""" + +import json +import os +import time + +import click + +from ..connection import ( + get_data_path, + load_auth_token, + load_connection_info, + send_message, +) +from ..output import output_response + + +@click.command(help="测试与 AstrBot 的连通性和延迟") +@click.option("-c", "--count", default=1, type=int, help="测试次数（默认 1）") +def ping(count: int) -> None: + """测试连通性和延迟 + + \b + 示例: + astr ping 单次测试 + astr ping -c 3 测试 3 次 + """ + for i in range(count): + start = time.time() + response = send_message("/help") + elapsed = (time.time() - start) * 1000 + + if response.get("status") == "success": + click.echo(f"pong: {elapsed:.0f}ms") + else: + error = response.get("error", "Unknown error") + click.echo(f"failed: {error}", err=True) + raise SystemExit(1) + + +@click.command(help="查看 AstrBot 连接状态") +def status() -> None: + """查看 AstrBot 连接状态 + + 检查连接文件、token、以及服务可达性 + """ + data_dir = get_data_path() + + # 检查连接文件 + connection_info = load_connection_info(data_dir) + if connection_info is not None: + conn_type = connection_info.get("type", "unknown") + if conn_type == "unix": + path = connection_info.get("path", "N/A") + click.echo("连接类型: Unix Socket") + click.echo(f"路径: {path}") + click.echo(f"文件存在: {os.path.exists(path)}") + elif conn_type == "tcp": + host = connection_info.get("host", "N/A") + port = connection_info.get("port", "N/A") + click.echo("连接类型: TCP Socket") + click.echo(f"地址: {host}:{port}") + else: + click.echo(f"连接类型: {conn_type} (未知)") + else: + click.echo("连接文件: 未找到 (.cli_connection)") + + # 检查 token + token = load_auth_token() + if token: + click.echo(f"Token: 已配置 ({token[:8]}...)") + else: + click.echo("Token: 未配置") + + # 测试连通性 + click.echo("---") + start = time.time() + response = send_message("/help") + elapsed = (time.time() - start) * 1000 + + if response.get("status") == "success": + click.echo(f"服务状态: 在线 ({elapsed:.0f}ms)") + else: + error = response.get("error", "Unknown error") + click.echo(f"服务状态: 离线 ({error})") + + +@click.group(help="测试工具 (子命令: echo/plugin)") +def test() -> None: + """测试工具命令组""" + + +@test.command(name="echo", help="发送消息并验证回环") +@click.argument("message", nargs=-1, required=True) +@click.option("-j", "--json", "use_json", is_flag=True, help="输出原始 JSON") +def test_echo(message: tuple[str, ...], use_json: bool) -> None: + """发送消息验证回环 + + \b + 示例: + astr test echo Hello 发送 Hello 并查看响应 + """ + msg = " ".join(message) + response = send_message(msg) + + if use_json: + click.echo(json.dumps(response, ensure_ascii=False, indent=2)) + else: + if response.get("status") == "success": + click.echo(f"发送: {msg}") + click.echo(f"响应: {response.get('response', '')}") + else: + error = response.get("error", "Unknown error") + click.echo(f"发送: {msg}") + click.echo(f"错误: {error}", err=True) + raise SystemExit(1) + + +@test.command(name="plugin", help="测试插件命令（发送 / ）") +@click.argument("name") +@click.argument("input_text", nargs=-1, required=True) +@click.option("-j", "--json", "use_json", is_flag=True, help="输出原始 JSON") +def test_plugin(name: str, input_text: tuple[str, ...], use_json: bool) -> None: + """测试插件命令 + + name 是插件注册的命令名（非插件名），会拼接为 / 发送。 + + \b + 示例: + astr test plugin probe cpu → 发送 /probe cpu + astr test plugin help → 发送 /help + """ + msg = f"/{name} {' '.join(input_text)}" + response = send_message(msg) + output_response(response, use_json) diff --git a/astrbot/cli/client/commands/interactive.py b/astrbot/cli/client/commands/interactive.py new file mode 100644 index 0000000000..b37e85ce1c --- /dev/null +++ b/astrbot/cli/client/commands/interactive.py @@ -0,0 +1,103 @@ +"""交互式 REPL 模式 - astr interactive""" + +import click + +from ..connection import send_message +from ..output import format_response + + +@click.command(help="进入交互式 REPL 模式") +def interactive() -> None: + """进入交互式 REPL 模式 + + \b + 特性: + - 直接输入消息发送给 AstrBot + - 支持 CLI 子命令（如 conv ls, plugin ls） + - /quit 或 Ctrl+C 退出 + - 支持命令历史（readline） + + \b + 示例: + astr interactive 进入交互模式 + astr -i 同上（快捷方式） + """ + # 子命令映射：REPL 中输入的前缀 -> 对应的内部命令格式 + _REPL_COMMAND_MAP = { + "conv ls": "/ls", + "conv new": "/new", + "conv switch": "/switch", + "conv del": "/del", + "conv rename": "/rename", + "conv reset": "/reset", + "conv history": "/history", + "plugin ls": "/plugin ls", + "plugin on": "/plugin on", + "plugin off": "/plugin off", + "plugin help": "/plugin help", + "provider": "/provider", + "model": "/model", + "key": "/key", + "help": "/help", + "sid": "/sid", + "t2i": "/t2i", + "tts": "/tts", + } + + # 尝试启用 readline 支持命令历史 + try: + import readline # noqa: F401 + except ImportError: + pass + + click.echo("AstrBot 交互模式 (输入 /quit 或 Ctrl+C 退出)") + click.echo("---") + + while True: + try: + line = input("astr> ").strip() + except (EOFError, KeyboardInterrupt): + click.echo("\n再见!") + break + + if not line: + continue + + if line in ("/quit", "/exit", "quit", "exit"): + click.echo("再见!") + break + + # 尝试匹配 REPL 子命令 + msg = _resolve_repl_command(line, _REPL_COMMAND_MAP) + + response = send_message(msg) + if response.get("status") == "success": + formatted = format_response(response) + if formatted: + click.echo(formatted) + else: + error = response.get("error", "Unknown error") + click.echo(f"Error: {error}", err=True) + + +def _resolve_repl_command(line: str, command_map: dict[str, str]) -> str: + """将 REPL 输入解析为内部命令 + + 先尝试匹配最长前缀的子命令映射，未匹配则原样发送。 + + Args: + line: 用户输入 + command_map: 子命令映射表 + + Returns: + 要发送的消息 + """ + # 按键长度降序匹配，确保 "conv ls" 优先于 "conv" + for prefix in sorted(command_map, key=len, reverse=True): + if line == prefix: + return command_map[prefix] + if line.startswith(prefix + " "): + rest = line[len(prefix) :].strip() + return f"{command_map[prefix]} {rest}" + + return line diff --git a/astrbot/cli/client/commands/log.py b/astrbot/cli/client/commands/log.py new file mode 100644 index 0000000000..3ead7d58cc --- /dev/null +++ b/astrbot/cli/client/commands/log.py @@ -0,0 +1,131 @@ +"""log 命令 - 获取 AstrBot 日志""" + +import os +import re + +import click + +from ..connection import get_data_path, get_logs + + +@click.command(help="获取 AstrBot 日志") +@click.option( + "--lines", default=100, type=int, help="返回的日志行数（默认 100，最大 1000）" +) +@click.option( + "--level", default="", help="按级别过滤 (DEBUG/INFO/WARNING/ERROR/CRITICAL)" +) +@click.option("--pattern", default="", help="按模式过滤（子串匹配）") +@click.option("--regex", is_flag=True, help="使用正则表达式匹配 pattern") +@click.option( + "--socket", + "use_socket", + is_flag=True, + help="通过 Socket 连接 AstrBot 获取日志（需要 AstrBot 运行）", +) +@click.option( + "-t", "--timeout", default=30.0, type=float, help="超时时间（仅 Socket 模式）" +) +def log( + lines: int, + level: str, + pattern: str, + regex: bool, + use_socket: bool, + timeout: float, +) -> None: + """获取 AstrBot 日志 + + \b + 示例: + astr log # 直接读取日志文件（默认） + astr log --lines 50 # 获取最近 50 行 + astr log --level ERROR # 只显示 ERROR 级别 + astr log --pattern "plugin" # 匹配包含 "plugin" 的日志 + astr log --pattern "ERRO|WARN" --regex # 使用正则表达式 + astr log --socket # 通过 Socket 连接 AstrBot 获取 + """ + if use_socket: + response = get_logs(None, timeout, lines, level, pattern, regex) + if response.get("status") == "success": + formatted = response.get("response", "") + click.echo(formatted) + else: + error = response.get("error", "Unknown error") + click.echo(f"Error: {error}", err=True) + raise SystemExit(1) + else: + _read_log_from_file(lines, level, pattern, regex) + + +def _read_log_from_file(lines: int, level: str, pattern: str, use_regex: bool) -> None: + """直接从日志文件读取 + + Args: + lines: 返回的日志行数 + level: 日志级别过滤 + pattern: 模式过滤 + use_regex: 是否使用正则表达式 + """ + LEVEL_MAP = { + "DEBUG": "DEBUG", + "INFO": "INFO", + "WARNING": "WARN", + "WARN": "WARN", + "ERROR": "ERRO", + "CRITICAL": "CRIT", + } + + level_filter = LEVEL_MAP.get(level.upper(), level.upper()) + + log_path = os.path.join(get_data_path(), "logs", "astrbot.log") + + if not os.path.exists(log_path): + click.echo( + f"Error: 日志文件未找到: {log_path}", + err=True, + ) + click.echo( + "提示: 请在配置中启用 log_file_enable 来记录日志到文件，或使用不带 --file 的方式连接 AstrBot", + err=True, + ) + raise SystemExit(1) + + try: + with open(log_path, encoding="utf-8", errors="ignore") as f: + all_lines = f.readlines() + + logs = [] + for line in reversed(all_lines): + if not line.strip(): + continue + + if level_filter: + if not re.search(rf"\[{level_filter}\]", line): + continue + + if pattern: + if use_regex: + try: + if not re.search(pattern, line): + continue + except re.error: + if pattern not in line: + continue + else: + if pattern not in line: + continue + + logs.append(line.rstrip()) + + if len(logs) >= lines: + break + + logs.reverse() + + for log_line in logs: + click.echo(log_line) + + except OSError as e: + click.echo(f"Error: 读取日志文件失败: {e}", err=True) + raise SystemExit(1) diff --git a/astrbot/cli/client/commands/plugin.py b/astrbot/cli/client/commands/plugin.py new file mode 100644 index 0000000000..09a9b981c0 --- /dev/null +++ b/astrbot/cli/client/commands/plugin.py @@ -0,0 +1,47 @@ +"""插件管理命令组 - astr plugin""" + +import click + +from ..connection import send_message +from ..output import output_response + + +@click.group(help="插件管理 (子命令: ls/on/off/help)") +def plugin() -> None: + """插件管理命令组""" + + +@plugin.command(name="ls", help="列出已安装插件") +@click.option("-j", "--json", "use_json", is_flag=True, help="输出原始 JSON") +def plugin_ls(use_json: bool) -> None: + """列出已安装插件""" + response = send_message("/plugin ls") + output_response(response, use_json) + + +@plugin.command(name="on", help="启用插件") +@click.argument("name") +@click.option("-j", "--json", "use_json", is_flag=True, help="输出原始 JSON") +def plugin_on(name: str, use_json: bool) -> None: + """启用插件""" + response = send_message(f"/plugin on {name}") + output_response(response, use_json) + + +@plugin.command(name="off", help="禁用插件") +@click.argument("name") +@click.option("-j", "--json", "use_json", is_flag=True, help="输出原始 JSON") +def plugin_off(name: str, use_json: bool) -> None: + """禁用插件""" + response = send_message(f"/plugin off {name}") + output_response(response, use_json) + + +@plugin.command(name="help", help="获取插件帮助") +@click.argument("name", default="", required=False) +@click.option("-j", "--json", "use_json", is_flag=True, help="输出原始 JSON") +def plugin_help(name: str, use_json: bool) -> None: + """获取插件帮助""" + cmd = "/plugin help" if not name else f"/plugin help {name}" + response = send_message(cmd) + output_response(response, use_json) diff --git a/astrbot/cli/client/commands/provider.py b/astrbot/cli/client/commands/provider.py new file mode 100644 index 0000000000..acd6d9a694 --- /dev/null +++ b/astrbot/cli/client/commands/provider.py @@ -0,0 +1,55 @@ +"""Provider/Model/Key 管理命令 - astr provider / astr model / astr key""" + +import click + +from ..connection import send_message +from ..output import output_response + + +@click.command(help="查看/切换 Provider") +@click.argument("index", default="", required=False) +@click.option("-j", "--json", "use_json", is_flag=True, help="输出原始 JSON") +def provider(index: str, use_json: bool) -> None: + """查看/切换 Provider + + \b + 示例: + astr provider 查看当前 Provider 列表 + astr provider 1 切换到 Provider 1 + """ + cmd = "/provider" if not index else f"/provider {index}" + response = send_message(cmd) + output_response(response, use_json) + + +@click.command(help="查看/切换模型") +@click.argument("index_or_name", default="", required=False) +@click.option("-j", "--json", "use_json", is_flag=True, help="输出原始 JSON") +def model(index_or_name: str, use_json: bool) -> None: + """查看/切换模型 + + \b + 示例: + astr model 查看当前模型列表 + astr model 1 切换到模型 1 + astr model gpt-4 按名称切换模型 + """ + cmd = "/model" if not index_or_name else f"/model {index_or_name}" + response = send_message(cmd) + output_response(response, use_json) + + +@click.command(help="查看/切换 Key") +@click.argument("index", default="", required=False) +@click.option("-j", "--json", "use_json", is_flag=True, help="输出原始 JSON") +def key(index: str, use_json: bool) -> None: + """查看/切换 Key + + \b + 示例: + astr key 查看当前 Key 列表 + astr key 1 切换到 Key 1 + """ + cmd = "/key" if not index else f"/key {index}" + response = send_message(cmd) + output_response(response, use_json) diff --git a/astrbot/cli/client/commands/send.py b/astrbot/cli/client/commands/send.py new file mode 100644 index 0000000000..e39310f375 --- /dev/null +++ b/astrbot/cli/client/commands/send.py @@ -0,0 +1,47 @@ +"""send 命令 - 发送消息给 AstrBot""" + +import sys + +import click + +from ..connection import send_message +from ..output import fix_git_bash_path, output_response + + +@click.command(help="发送消息给 AstrBot") +@click.argument("message", nargs=-1) +@click.option("-s", "--socket", "socket_path", default=None, help="Unix socket 路径") +@click.option("-t", "--timeout", default=30.0, type=float, help="超时时间（秒）") +@click.option("-j", "--json", "use_json", is_flag=True, help="输出原始 JSON 响应") +def send( + message: tuple[str, ...], socket_path: str | None, timeout: float, use_json: bool +) -> None: + """发送消息给 AstrBot + + \b + 示例: + astr send 你好 + astr send /help + astr send plugin ls + echo "你好" | astr send + """ + if message: + msg = " ".join(message) + msg = fix_git_bash_path(msg) + elif not sys.stdin.isatty(): + msg = sys.stdin.read().strip() + else: + click.echo("Error: 请提供消息内容", err=True) + raise SystemExit(1) + + if not msg: + click.echo("Error: 消息内容为空", err=True) + raise SystemExit(1) + + do_send(msg, socket_path, timeout, use_json) + + +def do_send(msg: str, socket_path: str | None, timeout: float, use_json: bool) -> None: + """执行消息发送并输出结果""" + response = send_message(msg, socket_path, timeout) + output_response(response, use_json) diff --git a/astrbot/cli/client/connection.py b/astrbot/cli/client/connection.py new file mode 100644 index 0000000000..373e705282 --- /dev/null +++ b/astrbot/cli/client/connection.py @@ -0,0 +1,304 @@ +"""连接管理模块 - 路径/token/socket/发送 + +从 __main__.py 提取的连接相关功能，不导入 astrbot 框架。 +""" + +import json +import os +import socket +import sys +import uuid + + +def get_data_path() -> str: + """获取数据目录路径 + + 优先级： + 1. 环境变量 ASTRBOT_ROOT + 2. 源码安装目录（通过 __file__ 获取） + 3. 当前工作目录 + """ + if root := os.environ.get("ASTRBOT_ROOT"): + return os.path.join(root, "data") + + source_root = os.path.realpath( + os.path.join(os.path.dirname(os.path.abspath(__file__)), "../../..") + ) + data_dir = os.path.join(source_root, "data") + + if os.path.exists(data_dir): + return data_dir + + return os.path.join(os.path.realpath(os.getcwd()), "data") + + +def get_temp_path() -> str: + """获取临时目录路径,兼容容器和非容器环境""" + if root := os.environ.get("ASTRBOT_ROOT"): + return os.path.join(root, "data", "temp") + + source_root = os.path.realpath( + os.path.join(os.path.dirname(os.path.abspath(__file__)), "../../..") + ) + temp_dir = os.path.join(source_root, "data", "temp") + if os.path.isdir(os.path.join(source_root, "data")): + return temp_dir + + import tempfile + + return tempfile.gettempdir() + + +def load_auth_token() -> str: + """从密钥文件加载认证token + + Returns: + token字符串,如果文件不存在则返回空字符串 + """ + token_file = os.path.join(get_data_path(), ".cli_token") + try: + with open(token_file, encoding="utf-8") as f: + return f.read().strip() + except FileNotFoundError: + return "" + except Exception: + return "" + + +def load_connection_info(data_dir: str) -> dict | None: + """加载连接信息 + + 从.cli_connection文件读取Socket连接信息 + + Args: + data_dir: 数据目录路径 + + Returns: + 连接信息字典，如果文件不存在则返回None + """ + connection_file = os.path.join(data_dir, ".cli_connection") + try: + with open(connection_file, encoding="utf-8") as f: + return json.load(f) + except FileNotFoundError: + return None + except json.JSONDecodeError as e: + print( + f"[ERROR] Invalid JSON in connection file: {connection_file}", + file=sys.stderr, + ) + print(f"[ERROR] {e}", file=sys.stderr) + return None + except Exception as e: + print( + f"[ERROR] Failed to load connection info: {e}", + file=sys.stderr, + ) + return None + + +def connect_to_server(connection_info: dict, timeout: float = 30.0) -> socket.socket: + """连接到服务器 + + 根据连接信息类型选择Unix Socket或TCP Socket连接 + + Args: + connection_info: 连接信息字典 + timeout: 超时时间（秒） + + Returns: + socket连接对象 + + Raises: + ValueError: 无效的连接类型 + ConnectionError: 连接失败 + """ + socket_type = connection_info.get("type") + + if socket_type == "unix": + socket_path = connection_info.get("path") + if not socket_path: + raise ValueError("Unix socket path is missing in connection info") + + try: + client_socket = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM) + client_socket.settimeout(timeout) + client_socket.connect(socket_path) + return client_socket + except FileNotFoundError: + raise ConnectionError( + f"Socket file not found: {socket_path}. Is AstrBot running?" + ) + except ConnectionRefusedError: + raise ConnectionError( + "Connection refused. Is AstrBot running in socket mode?" + ) + except Exception as e: + raise ConnectionError(f"Unix socket connection error: {e}") + + elif socket_type == "tcp": + host = connection_info.get("host") + port = connection_info.get("port") + if not host or not port: + raise ValueError("TCP host or port is missing in connection info") + + try: + client_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM) + client_socket.settimeout(timeout) + client_socket.connect((host, port)) + return client_socket + except ConnectionRefusedError: + raise ConnectionError( + f"Connection refused to {host}:{port}. Is AstrBot running?" + ) + except TimeoutError: + raise ConnectionError(f"Connection timeout to {host}:{port}") + except Exception as e: + raise ConnectionError(f"TCP socket connection error: {e}") + + else: + raise ValueError( + f"Invalid socket type: {socket_type}. Expected 'unix' or 'tcp'" + ) + + +def _receive_json_response(client_socket: socket.socket) -> dict: + """从 socket 接收并解析 JSON 响应 + + Args: + client_socket: socket连接对象 + + Returns: + 解析后的响应字典 + """ + response_data = b"" + while True: + chunk = client_socket.recv(4096) + if not chunk: + break + response_data += chunk + try: + return json.loads(response_data.decode("utf-8", errors="replace")) + except json.JSONDecodeError: + continue + + return json.loads(response_data.decode("utf-8", errors="replace")) + + +def _get_connected_socket( + socket_path: str | None = None, timeout: float = 30.0 +) -> socket.socket: + """获取已连接的 socket + + Args: + socket_path: Unix socket路径(向后兼容) + timeout: 超时时间（秒） + + Returns: + 已连接的 socket 对象 + + Raises: + ValueError, ConnectionError: 连接失败时 + """ + data_dir = get_data_path() + connection_info = load_connection_info(data_dir) + + if connection_info is not None: + return connect_to_server(connection_info, timeout) + + if socket_path is None: + socket_path = os.path.join(get_temp_path(), "astrbot.sock") + + fallback_info = {"type": "unix", "path": socket_path} + return connect_to_server(fallback_info, timeout) + + +def send_message( + message: str, socket_path: str | None = None, timeout: float = 30.0 +) -> dict: + """发送消息到AstrBot并获取响应 + + Args: + message: 要发送的消息 + socket_path: Unix socket路径(仅用于向后兼容) + timeout: 超时时间（秒） + + Returns: + 响应字典 + """ + auth_token = load_auth_token() + + request = {"message": message, "request_id": str(uuid.uuid4())} + if auth_token: + request["auth_token"] = auth_token + + try: + client_socket = _get_connected_socket(socket_path, timeout) + except (ValueError, ConnectionError) as e: + return {"status": "error", "error": str(e)} + except Exception as e: + return {"status": "error", "error": f"Connection error: {e}"} + + try: + request_data = json.dumps(request, ensure_ascii=False).encode("utf-8") + client_socket.sendall(request_data) + return _receive_json_response(client_socket) + except TimeoutError: + return {"status": "error", "error": "Request timeout"} + except Exception as e: + return {"status": "error", "error": f"Communication error: {e}"} + finally: + client_socket.close() + + +def get_logs( + socket_path: str | None = None, + timeout: float = 30.0, + lines: int = 100, + level: str = "", + pattern: str = "", + use_regex: bool = False, +) -> dict: + """获取AstrBot日志 + + Args: + socket_path: Socket路径 + timeout: 超时时间 + lines: 返回的日志行数 + level: 日志级别过滤 + pattern: 模式过滤 + use_regex: 是否使用正则表达式 + + Returns: + 响应字典 + """ + auth_token = load_auth_token() + + request = { + "action": "get_logs", + "request_id": str(uuid.uuid4()), + "lines": lines, + "level": level, + "pattern": pattern, + "regex": use_regex, + } + if auth_token: + request["auth_token"] = auth_token + + try: + client_socket = _get_connected_socket(socket_path, timeout) + except (ValueError, ConnectionError) as e: + return {"status": "error", "error": str(e)} + except Exception as e: + return {"status": "error", "error": f"Connection error: {e}"} + + try: + request_data = json.dumps(request, ensure_ascii=False).encode("utf-8") + client_socket.sendall(request_data) + return _receive_json_response(client_socket) + except TimeoutError: + return {"status": "error", "error": "Request timeout"} + except Exception as e: + return {"status": "error", "error": f"Communication error: {e}"} + finally: + client_socket.close() diff --git a/astrbot/cli/client/output.py b/astrbot/cli/client/output.py new file mode 100644 index 0000000000..178ca783c5 --- /dev/null +++ b/astrbot/cli/client/output.py @@ -0,0 +1,84 @@ +"""输出格式化模块 - 响应格式化与输出 + +从 __main__.py 提取的输出相关功能。 +""" + +import json +import re + +import click + + +def format_response(response: dict) -> str: + """格式化响应输出 + + 处理： + 1. 分段回复（每行一句） + 2. 图片占位符 + + Args: + response: 响应字典 + + Returns: + 格式化后的字符串 + """ + if response.get("status") != "success": + return "" + + text = response.get("response", "") + images = response.get("images", []) + image_count = len(images) + + lines = text.split("\n") + + if image_count > 0: + if image_count == 1: + lines.append("[图片]") + else: + lines.append(f"[{image_count}张图片]") + + return "\n".join(lines) + + +def fix_git_bash_path(message: str) -> str: + """修复 Git Bash 路径转换问题 + + Git Bash (MSYS2) 会把 /plugin ls 转换为 C:/Program Files/Git/plugin ls + 检测并还原原始命令 + + Args: + message: 被转换后的消息 + + Returns: + 修复后的消息 + """ + pattern = r"[A-Z]:/(Program Files/Git|msys[0-9]+/[^/]+)/([^/]+)" + match = re.match(pattern, message) + + if match: + command = match.group(2) + rest = message[match.end() :].lstrip() + if rest: + return f"/{command} {rest}" + return f"/{command}" + + return message + + +def output_response(response: dict, use_json: bool) -> None: + """统一输出响应 + + Args: + response: 响应字典 + use_json: 是否输出原始JSON + """ + if use_json: + click.echo(json.dumps(response, ensure_ascii=False, indent=2)) + else: + if response.get("status") == "success": + formatted = format_response(response) + click.echo(formatted) + else: + error = response.get("error", "Unknown error") + click.echo(f"Error: {error}", err=True) + raise SystemExit(1) diff --git a/tests/test_cli/test_client_commands.py b/tests/test_cli/test_client_commands.py new file mode 100644 index 0000000000..21d98d3094 --- /dev/null +++ b/tests/test_cli/test_client_commands.py @@ -0,0 +1,559 @@ +"""CLI Client 命令模块单元测试 + +使用 click.testing.CliRunner 测试 CLI 命令的参数解析和消息映射。 +""" + +import json +from unittest.mock import patch + +from click.testing import CliRunner + +from astrbot.cli.client.__main__ import main + + +def _mock_send(response_text="OK", status="success"): + """创建 mock send_message 返回指定响应""" + return {"status": status, "response": response_text, "images": []} + + +def _mock_send_error(error_text="Connection error"): + """创建 mock send_message 返回错误""" + return {"status": "error", "error": error_text} + + +class TestSendCommand: + """send 命令测试""" + + @patch("astrbot.cli.client.commands.send.send_message") + def test_basic_send(self, mock_send): + """基本消息发送""" + mock_send.return_value = _mock_send("你好!") + runner = CliRunner() + result = runner.invoke(main, ["send", "你好"]) + + assert result.exit_code == 0 + assert "你好!" in result.output + mock_send.assert_called_once_with("你好", None, 30.0) + + @patch("astrbot.cli.client.commands.send.send_message") + def test_send_with_json(self, mock_send): + """JSON 输出""" + mock_send.return_value = _mock_send("hello") + runner = CliRunner() + result = runner.invoke(main, ["send", "-j", "hello"]) + + assert result.exit_code == 0 + output = json.loads(result.output) + assert output["status"] == "success" + + @patch("astrbot.cli.client.commands.send.send_message") + def test_send_multi_word(self, mock_send): + """多个词拼接""" + mock_send.return_value = _mock_send("response") + runner = CliRunner() + result = runner.invoke(main, ["send", "hello", "world"]) + + assert result.exit_code == 0 + mock_send.assert_called_once_with("hello world", None, 30.0) + + @patch("astrbot.cli.client.commands.send.send_message") + def test_implicit_send(self, mock_send): + """astr 你好 隐式路由到 send""" + mock_send.return_value = _mock_send("response") + runner = CliRunner() + result = runner.invoke(main, ["你好"]) + + assert result.exit_code == 0 + mock_send.assert_called_once() + + @patch("astrbot.cli.client.commands.send.send_message") + def test_implicit_json_flag(self, mock_send): + """astr -j "test" 隐式路由到 send -j""" + mock_send.return_value = _mock_send("response") + runner = CliRunner() + result = runner.invoke(main, ["-j", "test"]) + + assert result.exit_code == 0 + output = json.loads(result.output) + assert output["status"] == "success" + + @patch("astrbot.cli.client.commands.send.send_message") + def test_send_error(self, mock_send): + """发送错误时退出码为 1""" + mock_send.return_value = _mock_send_error("Connection refused") + runner = CliRunner() + result = runner.invoke(main, ["send", "hello"]) + + assert result.exit_code == 1 + + def test_send_no_message(self): + """无消息内容时报错""" + runner = CliRunner() + result = runner.invoke(main, ["send"]) + + assert result.exit_code == 1 + + @patch("astrbot.cli.client.commands.send.send_message") + def test_send_with_timeout(self, mock_send): + """自定义超时时间""" + mock_send.return_value = _mock_send("ok") + runner = CliRunner() + result = runner.invoke(main, ["send", "-t", "60", "hello"]) + + assert result.exit_code == 0 + mock_send.assert_called_once_with("hello", None, 60.0) + + @patch("astrbot.cli.client.commands.send.send_message") + def test_pipe_input(self, mock_send): + """管道输入""" + mock_send.return_value = _mock_send("piped") + runner = CliRunner() + result = runner.invoke(main, ["send"], input="hello from pipe") + + assert result.exit_code == 0 + mock_send.assert_called_once_with("hello from pipe", None, 30.0) + + +class TestLogCommand: + """log 命令测试""" + + @patch("astrbot.cli.client.commands.log._read_log_from_file") + def test_log_default(self, mock_read): + """默认读取文件日志""" + runner = CliRunner() + result = runner.invoke(main, ["log"]) + + assert result.exit_code == 0 + mock_read.assert_called_once_with(100, "", "", False) + + @patch("astrbot.cli.client.commands.log._read_log_from_file") + def test_log_with_options(self, mock_read): + """带选项读取日志""" + runner = CliRunner() + result = runner.invoke( + main, ["log", "--lines", "50", "--level", "ERROR", "--pattern", "test"] + ) + + assert result.exit_code == 0 + mock_read.assert_called_once_with(50, "ERROR", "test", False) + + @patch("astrbot.cli.client.commands.log._read_log_from_file") + def test_log_regex(self, mock_read): + """正则匹配日志""" + runner = CliRunner() + result = runner.invoke(main, ["log", "--pattern", "ERR|WARN", "--regex"]) + + assert result.exit_code == 0 + mock_read.assert_called_once_with(100, "", "ERR|WARN", True) + + @patch("astrbot.cli.client.commands.log._read_log_from_file") + def test_log_compat_flag(self, mock_read): + """--log 兼容旧用法""" + runner = CliRunner() + result = runner.invoke(main, ["--log"]) + + assert result.exit_code == 0 + mock_read.assert_called_once() + + @patch("astrbot.cli.client.commands.log.get_logs") + def test_log_socket_mode(self, mock_get_logs): + """Socket 模式获取日志""" + mock_get_logs.return_value = { + "status": "success", + "response": "log line 1\nlog line 2", + } + runner = CliRunner() + result = runner.invoke(main, ["log", "--socket"]) + + assert result.exit_code == 0 + assert "log line 1" in result.output + + +class TestConvCommand: + """conv 命令组测试""" + + @patch("astrbot.cli.client.commands.conv.send_message") + def test_conv_ls(self, mock_send): + """列出对话""" + mock_send.return_value = _mock_send("对话列表...") + runner = CliRunner() + result = runner.invoke(main, ["conv", "ls"]) + + assert result.exit_code == 0 + mock_send.assert_called_once_with("/ls") + + @patch("astrbot.cli.client.commands.conv.send_message") + def test_conv_ls_page(self, mock_send): + """带页码列出对话""" + mock_send.return_value = _mock_send("第2页") + runner = CliRunner() + result = runner.invoke(main, ["conv", "ls", "2"]) + + assert result.exit_code == 0 + mock_send.assert_called_once_with("/ls 2") + + @patch("astrbot.cli.client.commands.conv.send_message") + def test_conv_new(self, mock_send): + """创建新对话""" + mock_send.return_value = _mock_send("已创建") + runner = CliRunner() + result = runner.invoke(main, ["conv", "new"]) + + assert result.exit_code == 0 + mock_send.assert_called_once_with("/new") + + @patch("astrbot.cli.client.commands.conv.send_message") + def test_conv_switch(self, mock_send): + """切换对话""" + mock_send.return_value = _mock_send("已切换") + runner = CliRunner() + result = runner.invoke(main, ["conv", "switch", "3"]) + + assert result.exit_code == 0 + mock_send.assert_called_once_with("/switch 3") + + @patch("astrbot.cli.client.commands.conv.send_message") + def test_conv_del(self, mock_send): + """删除对话""" + mock_send.return_value = _mock_send("已删除") + runner = CliRunner() + result = runner.invoke(main, ["conv", "del"]) + + assert result.exit_code == 0 + mock_send.assert_called_once_with("/del") + + @patch("astrbot.cli.client.commands.conv.send_message") + def test_conv_rename(self, mock_send): + """重命名对话""" + mock_send.return_value = _mock_send("已重命名") + runner = CliRunner() + result = runner.invoke(main, ["conv", "rename", "新名称"]) + + assert result.exit_code == 0 + mock_send.assert_called_once_with("/rename 新名称") + + @patch("astrbot.cli.client.commands.conv.send_message") + def test_conv_reset(self, mock_send): + """重置 LLM 会话""" + mock_send.return_value = _mock_send("已重置") + runner = CliRunner() + result = runner.invoke(main, ["conv", "reset"]) + + assert result.exit_code == 0 + mock_send.assert_called_once_with("/reset") + + @patch("astrbot.cli.client.commands.conv.send_message") + def test_conv_history(self, mock_send): + """查看对话记录""" + mock_send.return_value = _mock_send("记录...") + runner = CliRunner() + result = runner.invoke(main, ["conv", "history"]) + + assert result.exit_code == 0 + mock_send.assert_called_once_with("/history") + + @patch("astrbot.cli.client.commands.conv.send_message") + def test_conv_history_page(self, mock_send): + """带页码查看记录""" + mock_send.return_value = _mock_send("第2页") + runner = CliRunner() + result = runner.invoke(main, ["conv", "history", "2"]) + + assert result.exit_code == 0 + mock_send.assert_called_once_with("/history 2") + + +class TestPluginCommand: + """plugin 命令组测试""" + + @patch("astrbot.cli.client.commands.plugin.send_message") + def test_plugin_ls(self, mock_send): + """列出插件""" + mock_send.return_value = _mock_send("插件列表") + runner = CliRunner() + result = runner.invoke(main, ["plugin", "ls"]) + + assert result.exit_code == 0 + mock_send.assert_called_once_with("/plugin ls") + + @patch("astrbot.cli.client.commands.plugin.send_message") + def test_plugin_on(self, mock_send): + """启用插件""" + mock_send.return_value = _mock_send("已启用") + runner = CliRunner() + result = runner.invoke(main, ["plugin", "on", "myplugin"]) + + assert result.exit_code == 0 + mock_send.assert_called_once_with("/plugin on myplugin") + + @patch("astrbot.cli.client.commands.plugin.send_message") + def test_plugin_off(self, mock_send): + """禁用插件""" + mock_send.return_value = _mock_send("已禁用") + runner = CliRunner() + result = runner.invoke(main, ["plugin", "off", "myplugin"]) + + assert result.exit_code == 0 + mock_send.assert_called_once_with("/plugin off myplugin") + + @patch("astrbot.cli.client.commands.plugin.send_message") + def test_plugin_help(self, mock_send): + """获取插件帮助""" + mock_send.return_value = _mock_send("帮助信息") + runner = CliRunner() + result = runner.invoke(main, ["plugin", "help", "myplugin"]) + + assert result.exit_code == 0 + mock_send.assert_called_once_with("/plugin help myplugin") + + @patch("astrbot.cli.client.commands.plugin.send_message") + def test_plugin_help_no_name(self, mock_send): + """获取通用插件帮助""" + mock_send.return_value = _mock_send("通用帮助") + runner = CliRunner() + result = runner.invoke(main, ["plugin", "help"]) + + assert result.exit_code == 0 + mock_send.assert_called_once_with("/plugin help") + + +class TestProviderModelKey: + """provider/model/key 命令测试""" + + @patch("astrbot.cli.client.commands.provider.send_message") + def test_provider_list(self, mock_send): + """查看 Provider 列表""" + mock_send.return_value = _mock_send("provider list") + runner = CliRunner() + result = runner.invoke(main, ["provider"]) + + assert result.exit_code == 0 + mock_send.assert_called_once_with("/provider") + + @patch("astrbot.cli.client.commands.provider.send_message") + def test_provider_switch(self, mock_send): + """切换 Provider""" + mock_send.return_value = _mock_send("switched") + runner = CliRunner() + result = runner.invoke(main, ["provider", "2"]) + + assert result.exit_code == 0 + mock_send.assert_called_once_with("/provider 2") + + @patch("astrbot.cli.client.commands.provider.send_message") + def test_model_list(self, mock_send): + """查看模型列表""" + mock_send.return_value = _mock_send("model list") + runner = CliRunner() + result = runner.invoke(main, ["model"]) + + assert result.exit_code == 0 + mock_send.assert_called_once_with("/model") + + @patch("astrbot.cli.client.commands.provider.send_message") + def test_model_switch(self, mock_send): + """切换模型""" + mock_send.return_value = _mock_send("switched") + runner = CliRunner() + result = runner.invoke(main, ["model", "gpt-4"]) + + assert result.exit_code == 0 + mock_send.assert_called_once_with("/model gpt-4") + + @patch("astrbot.cli.client.commands.provider.send_message") + def test_key_list(self, mock_send): + """查看 Key 列表""" + mock_send.return_value = _mock_send("key list") + runner = CliRunner() + result = runner.invoke(main, ["key"]) + + assert result.exit_code == 0 + mock_send.assert_called_once_with("/key") + + @patch("astrbot.cli.client.commands.provider.send_message") + def test_key_switch(self, mock_send): + """切换 Key""" + mock_send.return_value = _mock_send("switched") + runner = CliRunner() + result = runner.invoke(main, ["key", "1"]) + + assert result.exit_code == 0 + mock_send.assert_called_once_with("/key 1") + + +class TestDebugCommands: + """调试命令测试""" + + @patch("astrbot.cli.client.commands.debug.send_message") + def test_ping(self, mock_send): + """ping 测试""" + mock_send.return_value = _mock_send("help text") + runner = CliRunner() + result = runner.invoke(main, ["ping"]) + + assert result.exit_code == 0 + assert "pong" in result.output + + @patch("astrbot.cli.client.commands.debug.send_message") + def test_ping_count(self, mock_send): + """多次 ping""" + mock_send.return_value = _mock_send("help text") + runner = CliRunner() + result = runner.invoke(main, ["ping", "-c", "3"]) + + assert result.exit_code == 0 + assert result.output.count("pong") == 3 + + @patch("astrbot.cli.client.commands.debug.send_message") + @patch("astrbot.cli.client.commands.debug.load_auth_token", return_value="tok123") + @patch( + "astrbot.cli.client.commands.debug.load_connection_info", + return_value={"type": "tcp", "host": "127.0.0.1", "port": 12345}, + ) + def test_status(self, mock_conn, mock_token, mock_send): + """status 命令""" + mock_send.return_value = _mock_send("help text") + runner = CliRunner() + result = runner.invoke(main, ["status"]) + + assert result.exit_code == 0 + assert "TCP" in result.output + assert "127.0.0.1" in result.output + assert "在线" in result.output + + @patch("astrbot.cli.client.commands.debug.send_message") + def test_test_echo(self, mock_send): + """test echo 命令""" + mock_send.return_value = _mock_send("echo response") + runner = CliRunner() + result = runner.invoke(main, ["test", "echo", "hello"]) + + assert result.exit_code == 0 + assert "hello" in result.output + assert "echo response" in result.output + + @patch("astrbot.cli.client.commands.debug.send_message") + def test_test_plugin(self, mock_send): + """test plugin 命令""" + mock_send.return_value = _mock_send("plugin response") + runner = CliRunner() + result = runner.invoke(main, ["test", "plugin", "hello", "world"]) + + assert result.exit_code == 0 + mock_send.assert_called_once_with("/hello world") + + +class TestAliasCommands: + """快捷别名命令测试""" + + @patch("astrbot.cli.client.connection.send_message") + def test_help_alias(self, mock_send): + """help 别名""" + mock_send.return_value = _mock_send("help text") + runner = CliRunner() + result = runner.invoke(main, ["help"]) + + assert result.exit_code == 0 + mock_send.assert_called_with("/help") + + @patch("astrbot.cli.client.connection.send_message") + def test_sid_alias(self, mock_send): + """sid 别名""" + mock_send.return_value = _mock_send("session_123") + runner = CliRunner() + result = runner.invoke(main, ["sid"]) + + assert result.exit_code == 0 + mock_send.assert_called_with("/sid") + + @patch("astrbot.cli.client.connection.send_message") + def test_t2i_alias(self, mock_send): + """t2i 别名""" + mock_send.return_value = _mock_send("toggled") + runner = CliRunner() + result = runner.invoke(main, ["t2i"]) + + assert result.exit_code == 0 + mock_send.assert_called_with("/t2i") + + @patch("astrbot.cli.client.connection.send_message") + def test_tts_alias(self, mock_send): + """tts 别名""" + mock_send.return_value = _mock_send("toggled") + runner = CliRunner() + result = runner.invoke(main, ["tts"]) + + assert result.exit_code == 0 + mock_send.assert_called_with("/tts") + + +class TestBatchCommand: + """batch 命令测试""" + + @patch("astrbot.cli.client.connection.send_message") + def test_batch(self, mock_send, tmp_path): + """批量执行""" + mock_send.return_value = _mock_send("ok") + + batch_file = tmp_path / "commands.txt" + batch_file.write_text("hello\n# comment\n/help\n\n/plugin ls\n") + + runner = CliRunner() + result = runner.invoke(main, ["batch", str(batch_file)]) + + assert result.exit_code == 0 + assert mock_send.call_count == 3 + mock_send.assert_any_call("hello") + mock_send.assert_any_call("/help") + mock_send.assert_any_call("/plugin ls") + + +class TestBackwardCompatibility: + """向后兼容性测试""" + + @patch("astrbot.cli.client.commands.send.send_message") + def test_astr_hello(self, mock_send): + """astr 你好 → astr send 你好""" + mock_send.return_value = _mock_send("hi") + runner = CliRunner() + result = runner.invoke(main, ["你好"]) + + assert result.exit_code == 0 + mock_send.assert_called_once() + + @patch("astrbot.cli.client.commands.log._read_log_from_file") + def test_astr_log_flag(self, mock_read): + """astr --log → astr log""" + runner = CliRunner() + result = runner.invoke(main, ["--log"]) + + assert result.exit_code == 0 + mock_read.assert_called_once() + + def test_help_output(self): + """帮助输出包含新命令""" + runner = CliRunner() + result = runner.invoke(main, ["--help"]) + + assert result.exit_code == 0 + assert "send" in result.output + assert "log" in result.output + assert "conv" in result.output + assert "plugin" in result.output + assert "provider" in result.output + assert "ping" in result.output + assert "interactive" in result.output + + +class TestInteractiveFlag: + """交互模式快捷方式测试""" + + @patch("astrbot.cli.client.commands.interactive.send_message") + def test_interactive_flag(self, mock_send): + """astr -i → astr interactive""" + runner = CliRunner() + # 输入 /quit 以退出交互模式 + result = runner.invoke(main, ["-i"], input="/quit\n") + + assert result.exit_code == 0 + assert "再见" in result.output diff --git a/tests/test_cli/test_client_connection.py b/tests/test_cli/test_client_connection.py new file mode 100644 index 0000000000..c21acca9e7 --- /dev/null +++ b/tests/test_cli/test_client_connection.py @@ -0,0 +1,267 @@ +"""CLI Client 连接模块单元测试""" + +import json +import os +from unittest.mock import MagicMock, patch + +import pytest + +from astrbot.cli.client.connection import ( + _receive_json_response, + connect_to_server, + get_data_path, + get_logs, + get_temp_path, + load_auth_token, + load_connection_info, + send_message, +) + + +class TestGetDataPath: + """get_data_path 路径解析测试""" + + def test_env_var_priority(self, tmp_path): + """环境变量 ASTRBOT_ROOT 优先""" + with patch.dict(os.environ, {"ASTRBOT_ROOT": str(tmp_path)}): + result = get_data_path() + assert result == os.path.join(str(tmp_path), "data") + + def test_fallback_to_source_root(self): + """回退到源码安装目录""" + with patch.dict(os.environ, {}, clear=True): + os.environ.pop("ASTRBOT_ROOT", None) + result = get_data_path() + assert result.endswith("data") + + def test_no_env_returns_data_suffix(self): + """返回路径以 data 结尾""" + with patch.dict(os.environ, {}, clear=True): + os.environ.pop("ASTRBOT_ROOT", None) + result = get_data_path() + assert os.path.basename(result) == "data" + + +class TestGetTempPath: + """get_temp_path 测试""" + + def test_env_var_priority(self, tmp_path): + """环境变量优先""" + with patch.dict(os.environ, {"ASTRBOT_ROOT": str(tmp_path)}): + result = get_temp_path() + assert result == os.path.join(str(tmp_path), "data", "temp") + + +class TestLoadAuthToken: + """load_auth_token 测试""" + + def test_token_found(self, tmp_path): + """正确读取 token""" + token_file = tmp_path / "data" / ".cli_token" + token_file.parent.mkdir(parents=True) + token_file.write_text("test_token_123") + + with patch( + "astrbot.cli.client.connection.get_data_path", + return_value=str(tmp_path / "data"), + ): + assert load_auth_token() == "test_token_123" + + def test_token_not_found(self, tmp_path): + """token 文件不存在返回空字符串""" + with patch( + "astrbot.cli.client.connection.get_data_path", + return_value=str(tmp_path / "nonexistent"), + ): + assert load_auth_token() == "" + + def test_token_strip_whitespace(self, tmp_path): + """去除 token 两端空白""" + token_file = tmp_path / "data" / ".cli_token" + token_file.parent.mkdir(parents=True) + token_file.write_text(" token_with_spaces \n") + + with patch( + "astrbot.cli.client.connection.get_data_path", + return_value=str(tmp_path / "data"), + ): + assert load_auth_token() == "token_with_spaces" + + +class TestLoadConnectionInfo: + """load_connection_info 测试""" + + def test_unix_connection(self, tmp_path): + """读取 Unix Socket 配置""" + conn_file = tmp_path / ".cli_connection" + conn_file.write_text(json.dumps({"type": "unix", "path": "/tmp/test.sock"})) + + result = load_connection_info(str(tmp_path)) + assert result == {"type": "unix", "path": "/tmp/test.sock"} + + def test_tcp_connection(self, tmp_path): + """读取 TCP 配置""" + conn_file = tmp_path / ".cli_connection" + conn_file.write_text( + json.dumps({"type": "tcp", "host": "127.0.0.1", "port": 12345}) + ) + + result = load_connection_info(str(tmp_path)) + assert result == {"type": "tcp", "host": "127.0.0.1", "port": 12345} + + def test_file_not_found(self, tmp_path): + """文件不存在返回 None""" + result = load_connection_info(str(tmp_path)) + assert result is None + + def test_invalid_json(self, tmp_path): + """无效 JSON 返回 None""" + conn_file = tmp_path / ".cli_connection" + conn_file.write_text("not json") + + result = load_connection_info(str(tmp_path)) + assert result is None + + +class TestConnectToServer: + """connect_to_server 测试""" + + def test_invalid_socket_type(self): + """无效连接类型抛出 ValueError""" + with pytest.raises(ValueError, match="Invalid socket type"): + connect_to_server({"type": "invalid"}) + + def test_unix_missing_path(self): + """Unix Socket 缺少路径抛出 ValueError""" + with pytest.raises(ValueError, match="path is missing"): + connect_to_server({"type": "unix"}) + + def test_tcp_missing_host(self): + """TCP 缺少 host 抛出 ValueError""" + with pytest.raises(ValueError, match="host or port is missing"): + connect_to_server({"type": "tcp", "host": "", "port": 1234}) + + def test_tcp_missing_port(self): + """TCP 缺少 port 抛出 ValueError""" + with pytest.raises(ValueError, match="host or port is missing"): + connect_to_server({"type": "tcp", "host": "127.0.0.1"}) + + +class TestReceiveJsonResponse: + """_receive_json_response 测试""" + + def test_single_chunk(self): + """单次接收完整 JSON""" + mock_socket = MagicMock() + data = json.dumps({"status": "success", "response": "hello"}).encode("utf-8") + mock_socket.recv.side_effect = [data, b""] + + result = _receive_json_response(mock_socket) + assert result["status"] == "success" + assert result["response"] == "hello" + + def test_multi_chunk(self): + """分多次接收 JSON""" + mock_socket = MagicMock() + data = json.dumps({"status": "success", "response": "hello"}).encode("utf-8") + # 分两块发送 + mid = len(data) // 2 + mock_socket.recv.side_effect = [data[:mid], data[mid:], b""] + + result = _receive_json_response(mock_socket) + assert result["status"] == "success" + + +class TestSendMessage: + """send_message 测试""" + + @patch("astrbot.cli.client.connection._get_connected_socket") + @patch("astrbot.cli.client.connection.load_auth_token", return_value="") + def test_success(self, mock_token, mock_socket): + """成功发送消息""" + mock_sock = MagicMock() + mock_socket.return_value = mock_sock + response_data = json.dumps({"status": "success", "response": "hi"}).encode( + "utf-8" + ) + mock_sock.recv.side_effect = [response_data, b""] + + result = send_message("hello") + assert result["status"] == "success" + assert result["response"] == "hi" + mock_sock.close.assert_called_once() + + @patch("astrbot.cli.client.connection._get_connected_socket") + @patch("astrbot.cli.client.connection.load_auth_token", return_value="token123") + def test_with_auth_token(self, mock_token, mock_socket): + """带 token 发送""" + mock_sock = MagicMock() + mock_socket.return_value = mock_sock + response_data = json.dumps({"status": "success"}).encode("utf-8") + mock_sock.recv.side_effect = [response_data, b""] + + send_message("hello") + + # 验证 sendall 包含 auth_token + sent_data = mock_sock.sendall.call_args[0][0] + sent_json = json.loads(sent_data) + assert sent_json["auth_token"] == "token123" + + @patch( + "astrbot.cli.client.connection._get_connected_socket", + side_effect=ConnectionError("refused"), + ) + @patch("astrbot.cli.client.connection.load_auth_token", return_value="") + def test_connection_error(self, mock_token, mock_socket): + """连接失败返回错误""" + result = send_message("hello") + assert result["status"] == "error" + assert "refused" in result["error"] + + @patch("astrbot.cli.client.connection._get_connected_socket") + @patch("astrbot.cli.client.connection.load_auth_token", return_value="") + def test_timeout(self, mock_token, mock_socket): + """超时返回错误""" + mock_sock = MagicMock() + mock_socket.return_value = mock_sock + mock_sock.sendall.side_effect = TimeoutError() + + result = send_message("hello") + assert result["status"] == "error" + assert "timeout" in result["error"].lower() + mock_sock.close.assert_called_once() + + +class TestGetLogs: + """get_logs 测试""" + + @patch("astrbot.cli.client.connection._get_connected_socket") + @patch("astrbot.cli.client.connection.load_auth_token", return_value="") + def test_success(self, mock_token, mock_socket): + """成功获取日志""" + mock_sock = MagicMock() + mock_socket.return_value = mock_sock + response_data = json.dumps( + {"status": "success", "response": "log lines..."} + ).encode("utf-8") + mock_sock.recv.side_effect = [response_data, b""] + + result = get_logs(lines=50, level="ERROR") + assert result["status"] == "success" + + # 验证请求参数 + sent_data = mock_sock.sendall.call_args[0][0] + sent_json = json.loads(sent_data) + assert sent_json["action"] == "get_logs" + assert sent_json["lines"] == 50 + assert sent_json["level"] == "ERROR" + + @patch( + "astrbot.cli.client.connection._get_connected_socket", + side_effect=ConnectionError("no server"), + ) + @patch("astrbot.cli.client.connection.load_auth_token", return_value="") + def test_connection_error(self, mock_token, mock_socket): + """连接失败返回错误""" + result = get_logs() + assert result["status"] == "error" diff --git a/tests/test_cli/test_client_e2e.py b/tests/test_cli/test_client_e2e.py new file mode 100644 index 0000000000..e9c417d7c4 --- /dev/null +++ b/tests/test_cli/test_client_e2e.py @@ -0,0 +1,618 @@ +"""CLI Client 长链条端到端测试 + +对框架各子模块按 SDK 粒度进行端到端测试。 +不使用 mock，直接通过真实 socket 连接到运行中的 AstrBot 服务端。 + +测试前提：AstrBot 已启动并开启 CLI 平台适配器（socket 模式）。 + +测试链路覆盖： + 客户端 connection 模块 + → TCP/Unix Socket 连接 + → Token 认证 + → SocketClientHandler.handle() + → MessageConverter.convert() + → CLIMessageEvent (事件创建/提交/finalize) + → Pipeline (内置命令/LLM/插件) + → ResponseBuilder.build_success/build_error + → 客户端 output 模块解析 + +运行方式： + pytest tests/test_cli/test_client_e2e.py -v # 需要 AstrBot 服务端运行 + pytest tests/test_cli/ --ignore=tests/test_cli/test_client_e2e.py # 只跑单元测试 +""" + +import os +import time + +import pytest + +from astrbot.cli.client.connection import ( + get_data_path, + get_logs, + load_auth_token, + load_connection_info, + send_message, +) +from astrbot.cli.client.output import format_response + +# 默认超时（秒）：内置命令应在此时间内返回 +_CMD_TIMEOUT = 30.0 +# LLM 管道超时（秒）：触发 LLM 的命令可能更慢 +_LLM_TIMEOUT = 60.0 + + +def _server_reachable() -> bool: + """检查 AstrBot 服务端是否可达""" + try: + resp = send_message("/help", timeout=10.0) + return resp.get("status") == "success" + except Exception: + return False + + +# 如果服务端不可达，跳过所有测试 +pytestmark = [ + pytest.mark.skipif( + not _server_reachable(), + reason="AstrBot 服务端未运行，跳过端到端测试", + ), + pytest.mark.e2e, +] + + +# ============================================================ +# 第一层：连接基础设施测试 +# ============================================================ + + +class TestConnectionInfra: + """连接基础设施端到端测试 + + 验证链路：客户端 → 连接文件 → Token → Socket 建立 + """ + + def test_data_path_exists(self): + """数据目录存在且可读""" + data_dir = get_data_path() + assert os.path.isdir(data_dir), f"数据目录不存在: {data_dir}" + + def test_connection_info_valid(self): + """连接信息文件存在且格式正确""" + data_dir = get_data_path() + info = load_connection_info(data_dir) + assert info is not None, "连接信息文件 .cli_connection 不存在" + assert "type" in info, "连接信息缺少 type 字段" + assert info["type"] in ("unix", "tcp"), f"未知连接类型: {info['type']}" + + if info["type"] == "tcp": + assert "host" in info + assert "port" in info + assert isinstance(info["port"], int) + elif info["type"] == "unix": + assert "path" in info + + def test_auth_token_configured(self): + """Token 已配置且非空""" + token = load_auth_token() + assert token, "Token 未配置（.cli_token 为空或不存在）" + assert len(token) > 8, f"Token 过短（{len(token)} 字符），疑似无效" + + def test_socket_roundtrip_latency(self): + """Socket 往返延迟合理（<10s）""" + start = time.time() + resp = send_message("/help") + elapsed = time.time() - start + + assert resp["status"] == "success" + assert elapsed < 10.0, f"Socket 往返延迟过大: {elapsed:.2f}s" + + +# ============================================================ +# 第二层：Token 认证链路测试 +# ============================================================ + + +class TestTokenAuth: + """Token 认证端到端测试 + + 验证链路： + 客户端 auth_token → SocketClientHandler → TokenManager.validate() + """ + + def test_valid_token_accepted(self): + """正确 Token 通过认证""" + resp = send_message("/help") + assert resp["status"] == "success" + # 如果 Token 无效会返回 AUTH_FAILED + assert resp.get("error_code") != "AUTH_FAILED" + + def test_response_has_request_id(self): + """响应包含 request_id（证明请求通过了完整链路）""" + resp = send_message("/help") + assert "request_id" in resp, "响应缺少 request_id" + assert len(resp["request_id"]) > 0 + + +# ============================================================ +# 第三层：消息转换与事件链路测试 +# ============================================================ + + +class TestMessagePipeline: + """消息处理管道端到端测试 + + 验证链路： + MessageConverter.convert() → CLIMessageEvent 创建 + → event_committer 提交 → Pipeline 处理 + → CLIMessageEvent.send() 缓冲 → finalize() + → ResponseBuilder.build_success() + """ + + def test_internal_command_help(self): + """/help 命令走完整管道并返回内置命令列表""" + resp = send_message("/help") + assert resp["status"] == "success" + text = resp["response"] + # /help 应返回内置指令列表 + assert "/help" in text, "响应中应包含 /help 指令说明" + assert "内置指令" in text or "帮助" in text or "AstrBot" in text + + def test_internal_command_sid(self): + """/sid 返回会话信息，验证 MessageConverter 的 session_id 设置""" + resp = send_message("/sid") + assert resp["status"] == "success" + text = resp["response"] + # /sid 应返回会话 ID 信息 + assert "cli_session" in text or "cli_user" in text or "UMO" in text + + def test_response_structure(self): + """响应结构符合 ResponseBuilder 输出格式""" + resp = send_message("/help") + assert resp["status"] == "success" + # ResponseBuilder.build_success 输出这些字段 + assert "response" in resp + assert "images" in resp + assert isinstance(resp["images"], list) + assert "request_id" in resp + + @pytest.mark.timeout(_LLM_TIMEOUT) + def test_plain_text_message(self): + """普通文本消息走 LLM 管道""" + resp = send_message("echo test 12345", timeout=_LLM_TIMEOUT) + assert resp["status"] == "success" + # LLM 或插件应该返回某种响应（不是空的） + assert resp["response"] or resp["images"] + + def test_empty_response_for_unknown_command(self): + """不存在的斜杠命令返回某种错误提示""" + resp = send_message("/nonexistent_cmd_xyz_123") + assert resp["status"] == "success" + # 内置命令系统通常会返回 "未知指令" 之类的提示 + # 或者当作普通消息走 LLM 管道 + + +# ============================================================ +# 第四层：会话管理端到端测试 +# ============================================================ + + +class TestSessionManagement: + """会话管理端到端测试 + + 验证链路： + /new → /ls → /switch → /rename → /history → /reset → /del + 所有命令在同一个 cli_session 上操作对话列表 + + 会话逻辑说明： + - 默认 use_isolated_sessions=False + - 所有 CLI 请求使用同一个 session_id: "cli_session" + - /new, /switch, /del 等操作的是"对话"（LLM上下文），不是 socket 会话 + """ + + def test_conversation_full_lifecycle(self): + """完整对话生命周期：创建 → 列表 → 重命名 → 历史 → 重置 → 删除""" + + # 1. 记住初始状态 + resp_ls_before = send_message("/ls") + assert resp_ls_before["status"] == "success" + + # 2. 创建新对话 + resp_new = send_message("/new") + assert resp_new["status"] == "success" + text_new = resp_new["response"] + assert "新对话" in text_new or "切换" in text_new + + # 3. 重命名 + test_name = "e2e_lifecycle_test" + resp_rename = send_message(f"/rename {test_name}") + assert resp_rename["status"] == "success" + assert "重命名" in resp_rename["response"] or "成功" in resp_rename["response"] + + # 4. 列表中应该能看到新对话 + resp_ls = send_message("/ls") + assert resp_ls["status"] == "success" + assert test_name in resp_ls["response"] + + # 5. 重置 LLM 会话 + resp_reset = send_message("/reset") + assert resp_reset["status"] == "success" + assert "清除" in resp_reset["response"] or "成功" in resp_reset["response"] + + # 6. 查看历史（重置后应为空或只有系统消息） + resp_history = send_message("/history") + assert resp_history["status"] == "success" + + # 7. 删除对话 + resp_del = send_message("/del") + assert resp_del["status"] == "success" + assert "删除" in resp_del["response"] or "成功" in resp_del["response"] + + def test_conversation_switch(self): + """对话切换：创建新对话后切换回旧对话""" + + # 确保有至少一个对话 + send_message("/new") + + # 列表 + resp_ls = send_message("/ls") + assert resp_ls["status"] == "success" + + # 切换到序号 1 + resp_switch = send_message("/switch 1") + assert resp_switch["status"] == "success" + assert "切换" in resp_switch["response"] + + # 清理 + send_message("/del") + + def test_session_id_consistency(self): + """/sid 在多次请求间返回相同会话信息（证明使用同一会话）""" + resp1 = send_message("/sid") + resp2 = send_message("/sid") + assert resp1["status"] == "success" + assert resp2["status"] == "success" + # 两次 /sid 应返回相同的会话信息 + assert resp1["response"] == resp2["response"] + + +# ============================================================ +# 第五层：插件系统端到端测试 +# ============================================================ + + +class TestPluginSystem: + """插件系统端到端测试 + + 验证链路：消息 → Pipeline → 插件路由 → 插件执行 → 响应 + """ + + def test_plugin_list(self): + """/plugin ls 返回已加载插件列表""" + resp = send_message("/plugin ls") + assert resp["status"] == "success" + text = resp["response"] + assert "插件" in text or "plugin" in text.lower() + # 至少有内置插件 + assert "astrbot" in text.lower() or "builtin" in text.lower() + + def test_plugin_help(self): + """/plugin help 返回插件帮助""" + resp = send_message("/plugin help") + assert resp["status"] == "success" + + def test_plugin_help_specific(self): + """/plugin help 返回特定插件帮助""" + # 先获取插件列表找到一个可用插件 + resp_ls = send_message("/plugin ls") + assert resp_ls["status"] == "success" + + # builtin_commands 一定存在 + resp_help = send_message("/plugin help builtin_commands") + assert resp_help["status"] == "success" + text = resp_help["response"] + assert "指令" in text or "帮助" in text or "help" in text.lower() + + +# ============================================================ +# 第六层：Provider/Model 管理端到端测试 +# ============================================================ + + +class TestProviderModel: + """Provider/Model 管理端到端测试 + + 验证链路：/provider, /model, /key 命令的完整管道处理 + """ + + def test_model_list(self): + """/model 返回可用模型列表""" + resp = send_message("/model") + assert resp["status"] == "success" + text = resp["response"] + # 应该包含模型列表或图片 + assert text or resp["images"] + + def test_key_list(self): + """/key 返回 Key 信息""" + resp = send_message("/key") + assert resp["status"] == "success" + text = resp["response"] + assert "Key" in text or "key" in text.lower() or "当前" in text + + +# ============================================================ +# 第七层：日志子系统端到端测试 +# ============================================================ + + +class TestLogSubsystem: + """日志子系统端到端测试 + + 验证链路（Socket 模式）： + get_logs 请求 → SocketClientHandler._get_logs() + → 读取日志文件 → 过滤 → 返回 + + 验证链路（文件直读）： + _read_log_from_file() → 读取 data/logs/astrbot.log + """ + + def test_get_logs_via_socket(self): + """通过 Socket 获取日志""" + resp = get_logs(lines=10) + assert resp["status"] == "success" + # 应该返回一些日志内容 + assert "response" in resp + + def test_get_logs_with_level_filter(self): + """日志级别过滤""" + resp = get_logs(lines=50, level="INFO") + assert resp["status"] == "success" + text = resp.get("response", "") + # 如果有日志，每行都应包含 [INFO] + if text.strip(): + for line in text.strip().split("\n"): + if line.strip(): + assert "[INFO]" in line, f"过滤后仍有非 INFO 日志: {line}" + + def test_get_logs_with_pattern(self): + """日志模式过滤""" + resp = get_logs(lines=50, pattern="CLI") + assert resp["status"] == "success" + text = resp.get("response", "") + if text.strip(): + for line in text.strip().split("\n"): + if line.strip(): + assert "CLI" in line or "cli" in line + + +# ============================================================ +# 第八层：客户端输出模块测试 +# ============================================================ + + +class TestClientOutput: + """客户端输出格式化端到端测试 + + 验证 format_response 正确解析真实服务端响应 + """ + + def test_format_text_response(self): + """格式化纯文本响应""" + resp = send_message("/help") + formatted = format_response(resp) + assert len(formatted) > 0 + assert "help" in formatted.lower() or "指令" in formatted + + @pytest.mark.timeout(_LLM_TIMEOUT) + def test_format_image_response(self): + """格式化含图片的响应""" + resp = send_message("/provider", timeout=_LLM_TIMEOUT) + if resp.get("images"): + formatted = format_response(resp) + assert "图片" in formatted + + def test_format_error_response(self): + """错误响应格式化为空字符串""" + fake_error = {"status": "error", "error": "test"} + formatted = format_response(fake_error) + assert formatted == "" + + +# ============================================================ +# 第九层：长链条场景测试 +# ============================================================ + + +class TestLongChainScenarios: + """长链条场景端到端测试 + + 模拟真实用户操作序列，验证多步骤跨模块交互。 + """ + + def test_scenario_new_user_onboarding(self): + """场景：新用户首次使用 + + 链路：status → help → sid → plugin ls → model + """ + # 1. 检查连接状态 + resp = send_message("/help") + assert resp["status"] == "success" + + # 2. 查看帮助 + resp = send_message("/help") + assert resp["status"] == "success" + assert "/help" in resp["response"] + + # 3. 获取会话信息 + resp = send_message("/sid") + assert resp["status"] == "success" + assert "cli" in resp["response"].lower() + + # 4. 查看插件 + resp = send_message("/plugin ls") + assert resp["status"] == "success" + + # 5. 查看模型 + resp = send_message("/model") + assert resp["status"] == "success" + + @pytest.mark.timeout(_LLM_TIMEOUT) + def test_scenario_conversation_workflow(self): + """场景：完整对话工作流 + + 链路：new → rename → ls → send msg → history → reset → del + """ + # 1. 创建新对话 + resp = send_message("/new") + assert resp["status"] == "success" + + # 2. 重命名 + resp = send_message("/rename e2e_workflow_test") + assert resp["status"] == "success" + + # 3. 确认在列表中 + resp = send_message("/ls") + assert resp["status"] == "success" + assert "e2e_workflow_test" in resp["response"] + + # 4. 发送消息（触发 LLM 管道） + resp = send_message("请回复OK", timeout=_LLM_TIMEOUT) + assert resp["status"] == "success" + + # 5. 查看历史（应该有刚才的对话） + resp = send_message("/history") + assert resp["status"] == "success" + history_text = resp["response"] + assert ( + "OK" in history_text or "请回复" in history_text or "历史" in history_text + ) + + # 6. 重置 + resp = send_message("/reset") + assert resp["status"] == "success" + + # 7. 删除 + resp = send_message("/del") + assert resp["status"] == "success" + + def test_scenario_plugin_inspection(self): + """场景：逐一检查插件信息 + + 链路：plugin ls → 解析插件名 → plugin help + """ + # 1. 获取插件列表 + resp = send_message("/plugin ls") + assert resp["status"] == "success" + + # 2. 对 builtin_commands 查看帮助 + resp = send_message("/plugin help builtin_commands") + assert resp["status"] == "success" + assert "指令" in resp["response"] or "帮助" in resp["response"] + + def test_scenario_rapid_fire_commands(self): + """场景：快速连续发送多条命令 + + 验证服务端能正确处理串行请求，不混淆响应。 + """ + commands = ["/help", "/sid", "/ls", "/model", "/key"] + responses = [] + + for cmd in commands: + resp = send_message(cmd) + assert resp["status"] == "success", f"命令 {cmd} 失败: {resp}" + responses.append(resp) + + # 验证每个响应的 request_id 都不同 + request_ids = [r["request_id"] for r in responses] + assert len(set(request_ids)) == len(request_ids), "request_id 不唯一" + + # 验证响应内容合理（不混淆） + # /help 的响应应包含 "指令" + assert "指令" in responses[0]["response"] or "帮助" in responses[0]["response"] + # /sid 的响应应包含 "cli" + assert "cli" in responses[1]["response"].lower() + + @pytest.mark.timeout(_LLM_TIMEOUT) + def test_scenario_conversation_isolation(self): + """场景：对话切换后上下文隔离 + + 验证 /new 创建新对话后，/history 应该为空或不含前一个对话内容。 + """ + # 1. 创建新对话 + resp = send_message("/new") + assert resp["status"] == "success" + + # 2. 发消息 + resp = send_message("isolation_marker_abc", timeout=_LLM_TIMEOUT) + assert resp["status"] == "success" + + # 3. 创建另一个新对话 + resp = send_message("/new") + assert resp["status"] == "success" + + # 4. 查看历史（新对话应该没有 isolation_marker_abc） + resp = send_message("/history") + assert resp["status"] == "success" + assert "isolation_marker_abc" not in resp["response"] + + # 清理：删除两个测试对话 + send_message("/del") + send_message("/switch 1") # 可能需要先切换 + # 找到并删除之前的对话 + resp_ls = send_message("/ls") + if "isolation_marker" in resp_ls.get("response", ""): + send_message("/del") + + +# ============================================================ +# 第十层：错误处理与边界条件测试 +# ============================================================ + + +class TestErrorHandling: + """错误处理与边界条件端到端测试""" + + @pytest.mark.timeout(_LLM_TIMEOUT) + def test_very_long_message(self): + """超长消息不导致崩溃""" + long_msg = "A" * 10000 + resp = send_message(long_msg, timeout=_LLM_TIMEOUT) + # 应该成功处理或返回合理错误，不能崩溃 + assert resp["status"] in ("success", "error") + + @pytest.mark.timeout(_LLM_TIMEOUT) + def test_unicode_message(self): + """Unicode 消息正确处理""" + resp = send_message("你好世界 🌍 こんにちは мир", timeout=_LLM_TIMEOUT) + assert resp["status"] == "success" + + @pytest.mark.timeout(_LLM_TIMEOUT) + def test_special_characters(self): + """特殊字符消息""" + resp = send_message('hello "world" <>&{}[]', timeout=_LLM_TIMEOUT) + assert resp["status"] == "success" + + def test_empty_command_args(self): + """/switch 无参数""" + resp = send_message("/switch") + assert resp["status"] == "success" + # 应该返回错误提示而不是崩溃 + + def test_invalid_switch_index(self): + """/switch 无效序号""" + resp = send_message("/switch 99999") + assert resp["status"] == "success" + # 应该返回错误提示 + + def test_concurrent_stability(self): + """多次快速请求稳定性（允许偶发失败但大多数应成功）""" + success_count = 0 + total = 5 + for i in range(total): + resp = send_message("/help") + if resp["status"] == "success": + success_count += 1 + # 至少 80% 成功 + assert success_count >= total * 0.8, ( + f"并发稳定性不足: {success_count}/{total} 成功" + ) diff --git a/tests/test_cli/test_client_interactive.py b/tests/test_cli/test_client_interactive.py new file mode 100644 index 0000000000..b56ab3428b --- /dev/null +++ b/tests/test_cli/test_client_interactive.py @@ -0,0 +1,206 @@ +"""CLI Client 交互模式单元测试""" + +from unittest.mock import patch + +from astrbot.cli.client.commands.interactive import _resolve_repl_command + + +class TestResolveReplCommand: + """REPL 命令解析测试""" + + def setup_method(self): + """设置命令映射表""" + self.command_map = { + "conv ls": "/ls", + "conv new": "/new", + "conv switch": "/switch", + "conv del": "/del", + "conv rename": "/rename", + "conv reset": "/reset", + "conv history": "/history", + "plugin ls": "/plugin ls", + "plugin on": "/plugin on", + "plugin off": "/plugin off", + "plugin help": "/plugin help", + "provider": "/provider", + "model": "/model", + "key": "/key", + "help": "/help", + "sid": "/sid", + "t2i": "/t2i", + "tts": "/tts", + } + + def test_conv_ls(self): + """conv ls 映射到 /ls""" + assert _resolve_repl_command("conv ls", self.command_map) == "/ls" + + def test_conv_ls_with_page(self): + """conv ls 2 映射到 /ls 2""" + assert _resolve_repl_command("conv ls 2", self.command_map) == "/ls 2" + + def test_conv_switch(self): + """conv switch 3 映射到 /switch 3""" + assert _resolve_repl_command("conv switch 3", self.command_map) == "/switch 3" + + def test_conv_rename(self): + """conv rename 新名称 映射""" + assert ( + _resolve_repl_command("conv rename 新名称", self.command_map) + == "/rename 新名称" + ) + + def test_plugin_ls(self): + """plugin ls 映射""" + assert _resolve_repl_command("plugin ls", self.command_map) == "/plugin ls" + + def test_plugin_on(self): + """plugin on name 映射""" + assert ( + _resolve_repl_command("plugin on myplugin", self.command_map) + == "/plugin on myplugin" + ) + + def test_provider(self): + """provider 映射""" + assert _resolve_repl_command("provider", self.command_map) == "/provider" + + def test_provider_with_index(self): + """provider 1 映射""" + assert _resolve_repl_command("provider 1", self.command_map) == "/provider 1" + + def test_model(self): + """model 映射""" + assert _resolve_repl_command("model", self.command_map) == "/model" + + def test_model_with_name(self): + """model gpt-4 映射""" + assert _resolve_repl_command("model gpt-4", self.command_map) == "/model gpt-4" + + def test_help(self): + """help 映射""" + assert _resolve_repl_command("help", self.command_map) == "/help" + + def test_sid(self): + """sid 映射""" + assert _resolve_repl_command("sid", self.command_map) == "/sid" + + def test_passthrough_message(self): + """普通消息原样传递""" + assert _resolve_repl_command("你好", self.command_map) == "你好" + + def test_passthrough_slash_command(self): + """斜杠命令原样传递""" + assert _resolve_repl_command("/help", self.command_map) == "/help" + + def test_passthrough_unknown(self): + """未知命令原样传递""" + assert _resolve_repl_command("unknown cmd", self.command_map) == "unknown cmd" + + def test_exact_match_priority(self): + """精确匹配优先于前缀匹配""" + assert _resolve_repl_command("conv ls", self.command_map) == "/ls" + + def test_key(self): + """key 映射""" + assert _resolve_repl_command("key", self.command_map) == "/key" + + def test_key_with_index(self): + """key 1 映射""" + assert _resolve_repl_command("key 1", self.command_map) == "/key 1" + + def test_t2i(self): + """t2i 映射""" + assert _resolve_repl_command("t2i", self.command_map) == "/t2i" + + def test_tts(self): + """tts 映射""" + assert _resolve_repl_command("tts", self.command_map) == "/tts" + + +class TestInteractiveRepl: + """交互模式 REPL 测试""" + + @patch("astrbot.cli.client.commands.interactive.send_message") + def test_quit(self, mock_send): + """输入 /quit 退出""" + from click.testing import CliRunner + + from astrbot.cli.client.commands.interactive import interactive + + runner = CliRunner() + result = runner.invoke(interactive, input="/quit\n") + + assert result.exit_code == 0 + assert "再见" in result.output + + @patch("astrbot.cli.client.commands.interactive.send_message") + def test_exit(self, mock_send): + """输入 exit 退出""" + from click.testing import CliRunner + + from astrbot.cli.client.commands.interactive import interactive + + runner = CliRunner() + result = runner.invoke(interactive, input="exit\n") + + assert result.exit_code == 0 + assert "再见" in result.output + + @patch("astrbot.cli.client.commands.interactive.send_message") + def test_send_message(self, mock_send): + """在 REPL 中发送消息""" + from click.testing import CliRunner + + from astrbot.cli.client.commands.interactive import interactive + + mock_send.return_value = {"status": "success", "response": "hi", "images": []} + + runner = CliRunner() + result = runner.invoke(interactive, input="你好\n/quit\n") + + assert result.exit_code == 0 + mock_send.assert_any_call("你好") + + @patch("astrbot.cli.client.commands.interactive.send_message") + def test_empty_line_ignored(self, mock_send): + """空行被忽略""" + from click.testing import CliRunner + + from astrbot.cli.client.commands.interactive import interactive + + runner = CliRunner() + result = runner.invoke(interactive, input="\n\n/quit\n") + + assert result.exit_code == 0 + mock_send.assert_not_called() + + @patch("astrbot.cli.client.commands.interactive.send_message") + def test_repl_command_mapping(self, mock_send): + """REPL 中子命令映射""" + from click.testing import CliRunner + + from astrbot.cli.client.commands.interactive import interactive + + mock_send.return_value = {"status": "success", "response": "ok", "images": []} + + runner = CliRunner() + result = runner.invoke(interactive, input="conv ls\n/quit\n") + + assert result.exit_code == 0 + mock_send.assert_any_call("/ls") + + @patch("astrbot.cli.client.commands.interactive.send_message") + def test_error_response(self, mock_send): + """错误响应显示""" + from click.testing import CliRunner + + from astrbot.cli.client.commands.interactive import interactive + + mock_send.return_value = {"status": "error", "error": "Connection failed"} + + runner = CliRunner() + result = runner.invoke(interactive, input="hello\n/quit\n") + + assert result.exit_code == 0 + assert "Connection failed" in result.output From 78d1a1ff4d725641ba0cdfcc076c4332f53ccf22 Mon Sep 17 00:00:00 2001 From: YukiRa1n <167516635+YukiRa1n@users.noreply.github.com> Date: Thu, 19 Feb 2026 21:27:07 +0800 Subject: [PATCH 32/39] =?UTF-8?q?refactor(cli):=20=E6=89=81=E5=B9=B3?= =?UTF-8?q?=E5=8C=96CLI=E9=80=82=E9=85=8D=E5=99=A8=E7=BB=93=E6=9E=84?= =?UTF-8?q?=EF=BC=8C=E4=B8=8E=E5=85=B6=E4=BB=96=E9=80=82=E9=85=8D=E5=99=A8?= =?UTF-8?q?=E9=A3=8E=E6=A0=BC=E5=AF=B9=E9=BD=90?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit 将26文件3层嵌套结构合并为7文件扁平结构： - cli_adapter.py 合并 config_loader/token_manager/session_manager - cli_event.py 合并 converter/response_builder/image_processor - socket_server.py 合并 socket_abstract/tcp/unix/factory/platform_detector - socket_handler.py 合并 handlers/socket_handler/connection_info_writer - tty_handler.py/file_handler.py 从 handlers/ 提升到根目录 - 删除 interfaces.py/decorators.py 等过度工程化模块 - 修复 flaky 测试 test_scenario_new_user_onboarding --- astrbot/core/platform/sources/cli/__init__.py | 8 +- .../core/platform/sources/cli/cli_adapter.py | 275 +++++++--- .../core/platform/sources/cli/cli_event.py | 301 +++++++++-- .../platform/sources/cli/config/__init__.py | 6 - .../sources/cli/config/config_loader.py | 224 -------- .../sources/cli/config/token_manager.py | 99 ---- .../sources/cli/connection_info_writer.py | 120 ----- .../cli/{handlers => }/file_handler.py | 56 +- .../platform/sources/cli/handlers/__init__.py | 7 - .../core/platform/sources/cli/interfaces.py | 91 ---- .../platform/sources/cli/message/__init__.py | 14 - .../platform/sources/cli/message/converter.py | 76 --- .../sources/cli/message/image_processor.py | 247 --------- .../sources/cli/message/response_builder.py | 84 --- .../sources/cli/message/response_collector.py | 104 ---- .../platform/sources/cli/platform_detector.py | 255 --------- .../platform/sources/cli/session/__init__.py | 5 - .../sources/cli/session/session_manager.py | 123 ----- .../platform/sources/cli/socket_abstract.py | 120 ----- .../platform/sources/cli/socket_factory.py | 218 -------- .../cli/{handlers => }/socket_handler.py | 233 ++++---- .../platform/sources/cli/socket_server.py | 249 +++++++++ .../platform/sources/cli/tcp_socket_server.py | 247 --------- .../sources/cli/{handlers => }/tty_handler.py | 39 +- .../sources/cli/unix_socket_server.py | 213 -------- .../platform/sources/cli/utils/__init__.py | 56 -- .../platform/sources/cli/utils/decorators.py | 496 ------------------ tests/test_cli/test_client_e2e.py | 23 +- tests/test_cli/test_decorators.py | 408 -------------- tests/test_cli/test_e2e.py | 39 +- tests/test_cli/test_image_processor.py | 88 ++-- tests/test_cli/test_message_converter.py | 6 +- tests/test_cli/test_response_builder.py | 14 +- tests/test_cli/test_token_manager.py | 24 +- 34 files changed, 965 insertions(+), 3603 deletions(-) delete mode 100644 astrbot/core/platform/sources/cli/config/__init__.py delete mode 100644 astrbot/core/platform/sources/cli/config/config_loader.py delete mode 100644 astrbot/core/platform/sources/cli/config/token_manager.py delete mode 100644 astrbot/core/platform/sources/cli/connection_info_writer.py rename astrbot/core/platform/sources/cli/{handlers => }/file_handler.py (77%) delete mode 100644 astrbot/core/platform/sources/cli/handlers/__init__.py delete mode 100644 astrbot/core/platform/sources/cli/interfaces.py delete mode 100644 astrbot/core/platform/sources/cli/message/__init__.py delete mode 100644 astrbot/core/platform/sources/cli/message/converter.py delete mode 100644 astrbot/core/platform/sources/cli/message/image_processor.py delete mode 100644 astrbot/core/platform/sources/cli/message/response_builder.py delete mode 100644 astrbot/core/platform/sources/cli/message/response_collector.py delete mode 100644 astrbot/core/platform/sources/cli/platform_detector.py delete mode 100644 astrbot/core/platform/sources/cli/session/__init__.py delete mode 100644 astrbot/core/platform/sources/cli/session/session_manager.py delete mode 100644 astrbot/core/platform/sources/cli/socket_abstract.py delete mode 100644 astrbot/core/platform/sources/cli/socket_factory.py rename astrbot/core/platform/sources/cli/{handlers => }/socket_handler.py (62%) create mode 100644 astrbot/core/platform/sources/cli/socket_server.py delete mode 100644 astrbot/core/platform/sources/cli/tcp_socket_server.py rename astrbot/core/platform/sources/cli/{handlers => }/tty_handler.py (79%) delete mode 100644 astrbot/core/platform/sources/cli/unix_socket_server.py delete mode 100644 astrbot/core/platform/sources/cli/utils/__init__.py delete mode 100644 astrbot/core/platform/sources/cli/utils/decorators.py delete mode 100644 tests/test_cli/test_decorators.py diff --git a/astrbot/core/platform/sources/cli/__init__.py b/astrbot/core/platform/sources/cli/__init__.py index 1c087f0069..a8532db5e4 100644 --- a/astrbot/core/platform/sources/cli/__init__.py +++ b/astrbot/core/platform/sources/cli/__init__.py @@ -1,5 +1,4 @@ -""" -CLI Platform Adapter Module +"""CLI Platform Adapter Module 命令行模拟器平台适配器，用于快速测试AstrBot插件。 """ @@ -7,4 +6,7 @@ from .cli_adapter import CLIPlatformAdapter from .cli_event import CLIMessageEvent -__all__ = ["CLIPlatformAdapter", "CLIMessageEvent"] +__all__ = [ + "CLIPlatformAdapter", + "CLIMessageEvent", +] diff --git a/astrbot/core/platform/sources/cli/cli_adapter.py b/astrbot/core/platform/sources/cli/cli_adapter.py index d070eb3c57..088a731144 100644 --- a/astrbot/core/platform/sources/cli/cli_adapter.py +++ b/astrbot/core/platform/sources/cli/cli_adapter.py @@ -1,19 +1,13 @@ -""" -CLI Platform Adapter - CLI平台适配器 +"""CLI平台适配器 编排层：组合各模块实现CLI测试功能。 -遵循Unix哲学：原子化模块、显式I/O、管道编排。 - -重构后架构: - cli_adapter.py (编排层 <200行) - ├── ConfigLoader 加载配置 - ├── TokenManager 管理认证 - ├── SessionManager 管理会话 - ├── MessageConverter 转换消息 - └── Handler (Socket/TTY/File) """ import asyncio +import json +import os +import secrets +import time from collections.abc import Awaitable from typing import Any @@ -21,19 +15,183 @@ from astrbot.core.message.message_event_result import MessageChain from astrbot.core.platform import Platform, PlatformMetadata from astrbot.core.platform.astr_message_event import MessageSesion -from astrbot.core.utils.astrbot_path import get_astrbot_data_path +from astrbot.core.utils.astrbot_path import get_astrbot_data_path, get_astrbot_temp_path from ...register import register_platform_adapter -from .config.config_loader import ConfigLoader -from .config.token_manager import TokenManager -from .connection_info_writer import write_connection_info -from .handlers.file_handler import FileHandler -from .handlers.socket_handler import SocketClientHandler, SocketModeHandler -from .handlers.tty_handler import TTYHandler -from .message.converter import MessageConverter -from .platform_detector import detect_platform -from .session.session_manager import SessionManager -from .socket_factory import create_socket_server +from .cli_event import MessageConverter +from .file_handler import FileHandler +from .socket_handler import ( + SocketClientHandler, + SocketModeHandler, + write_connection_info, +) +from .socket_server import create_socket_server, detect_platform +from .tty_handler import TTYHandler + +# ------------------------------------------------------------------ +# Token管理 +# ------------------------------------------------------------------ + + +class TokenManager: + """Token管理器""" + + TOKEN_FILE = ".cli_token" + + def __init__(self): + self._token: str | None = None + self._token_file = os.path.join(get_astrbot_data_path(), self.TOKEN_FILE) + + @property + def token(self) -> str | None: + if self._token is None: + self._token = self._ensure_token() + return self._token + + def _ensure_token(self) -> str | None: + try: + if os.path.exists(self._token_file): + with open(self._token_file, encoding="utf-8") as f: + token = f.read().strip() + if token: + logger.info("[CLI] Authentication token loaded from file") + return token + + token = secrets.token_urlsafe(32) + with open(self._token_file, "w", encoding="utf-8") as f: + f.write(token) + try: + os.chmod(self._token_file, 0o600) + except OSError: + pass + logger.info(f"[CLI] Generated new authentication token: {token}") + logger.info(f"[CLI] Token saved to: {self._token_file}") + return token + except Exception as e: + logger.error(f"[CLI] Failed to ensure token: {e}") + logger.warning("[CLI] Authentication disabled due to token error") + return None + + def validate(self, provided_token: str) -> bool: + if not self.token: + return True + if not provided_token: + logger.warning("[CLI] Request rejected: missing auth_token") + return False + if provided_token != self.token: + logger.warning( + f"[CLI] Request rejected: invalid auth_token (length={len(provided_token)})" + ) + return False + return True + + +# ------------------------------------------------------------------ +# 会话管理 +# ------------------------------------------------------------------ + + +class SessionManager: + """会话管理器""" + + CLEANUP_INTERVAL = 10 + + def __init__(self, ttl: int = 30, enabled: bool = False): + self.ttl = ttl + self.enabled = enabled + self._timestamps: dict[str, float] = {} + self._cleanup_task: asyncio.Task | None = None + self._running = False + + def register(self, session_id: str) -> None: + if not self.enabled: + return + if session_id not in self._timestamps: + self._timestamps[session_id] = time.time() + logger.debug( + f"[CLI] Created isolated session: {session_id}, TTL={self.ttl}s" + ) + + def touch(self, session_id: str) -> None: + if self.enabled and session_id in self._timestamps: + self._timestamps[session_id] = time.time() + + def is_expired(self, session_id: str) -> bool: + if not self.enabled: + return False + timestamp = self._timestamps.get(session_id) + if timestamp is None: + return True + return time.time() - timestamp > self.ttl + + def start_cleanup_task(self) -> None: + if not self.enabled: + return + self._running = True + self._cleanup_task = asyncio.create_task(self._cleanup_loop()) + logger.info(f"[CLI] Session cleanup task started, TTL={self.ttl}s") + + async def stop_cleanup_task(self) -> None: + self._running = False + if self._cleanup_task and not self._cleanup_task.done(): + self._cleanup_task.cancel() + try: + await self._cleanup_task + except asyncio.CancelledError: + pass + + async def _cleanup_loop(self) -> None: + while self._running: + try: + await asyncio.sleep(self.CLEANUP_INTERVAL) + if not self.enabled: + continue + current_time = time.time() + expired = [ + sid + for sid, ts in list(self._timestamps.items()) + if current_time - ts > self.ttl + ] + for session_id in expired: + logger.info(f"[CLI] Cleaning expired session: {session_id}") + self._timestamps.pop(session_id, None) + if expired: + logger.info(f"[CLI] Cleaned {len(expired)} expired sessions") + except asyncio.CancelledError: + break + except Exception as e: + logger.error(f"[CLI] Session cleanup error: {e}") + logger.info("[CLI] Session cleanup task stopped") + + +# ------------------------------------------------------------------ +# 配置加载 +# ------------------------------------------------------------------ + + +def _load_config(platform_config: dict, platform_settings: dict | None = None) -> dict: + """加载配置，合并配置文件覆盖""" + config_filename = platform_config.get("config_file", "cli_config.json") + config_path = os.path.join(get_astrbot_data_path(), config_filename) + + if os.path.exists(config_path): + try: + with open(config_path, encoding="utf-8") as f: + file_config = json.load(f) + logger.info(f"[CLI] Loaded config from {config_path}") + if "platform_config" in file_config: + merged = platform_config.copy() + merged.update(file_config["platform_config"]) + platform_config = merged + except Exception as e: + logger.warning(f"[CLI] Failed to load config from {config_path}: {e}") + + return platform_config + + +# ------------------------------------------------------------------ +# CLI平台适配器 +# ------------------------------------------------------------------ @register_platform_adapter( @@ -54,10 +212,7 @@ support_streaming_message=False, ) class CLIPlatformAdapter(Platform): - """CLI平台适配器 - 编排层 - - 通过组合各模块实现CLI测试功能。 - """ + """CLI平台适配器""" def __init__( self, @@ -65,17 +220,33 @@ def __init__( platform_settings: dict, event_queue: asyncio.Queue, ) -> None: - """初始化CLI平台适配器""" super().__init__(platform_config, event_queue) # 加载配置 - self.config = ConfigLoader.load(platform_config, platform_settings) + cfg = _load_config(platform_config, platform_settings) + self.mode = cfg.get("mode", "socket") + self.socket_type = cfg.get("socket_type", "auto") + self.socket_path = cfg.get("socket_path") or os.path.join( + get_astrbot_temp_path(), "astrbot.sock" + ) + self.tcp_host = cfg.get("tcp_host", "127.0.0.1") + self.tcp_port = cfg.get("tcp_port", 0) + self.input_file = cfg.get("input_file") or os.path.join( + get_astrbot_temp_path(), "astrbot_cli", "input.txt" + ) + self.output_file = cfg.get("output_file") or os.path.join( + get_astrbot_temp_path(), "astrbot_cli", "output.txt" + ) + self.poll_interval = cfg.get("poll_interval", 1.0) + self.use_isolated_sessions = cfg.get("use_isolated_sessions", False) + self.session_ttl = cfg.get("session_ttl", 30) + self.whitelist = cfg.get("whitelist", []) + self.platform_id = cfg.get("id", "cli") - # 初始化各模块 + # 初始化模块 self.token_manager = TokenManager() self.session_manager = SessionManager( - ttl=self.config.session_ttl, - enabled=self.config.use_isolated_sessions, + ttl=self.session_ttl, enabled=self.use_isolated_sessions ) self.message_converter = MessageConverter() @@ -83,7 +254,7 @@ def __init__( self.metadata = PlatformMetadata( name="cli", description="命令行模拟器", - id=self.config.platform_id, + id=self.platform_id, support_streaming_message=False, ) @@ -92,29 +263,23 @@ def __init__( self._output_queue: asyncio.Queue = asyncio.Queue() self._handler = None - logger.info("[CLI] Adapter initialized, mode=%s", self.config.mode) + logger.info(f"[CLI] Adapter initialized, mode={self.mode}") def run(self) -> Awaitable[Any]: - """启动CLI平台""" return self._run_loop() async def _run_loop(self) -> None: - """主运行循环 - 根据模式选择Handler""" self._running = True - - # 启动会话清理任务 self.session_manager.start_cleanup_task() try: - # 根据模式创建并运行Handler - if self.config.mode == "socket": + if self.mode == "socket": await self._run_socket_mode() - elif self.config.mode == "tty": + elif self.mode == "tty": await self._run_tty_mode() - elif self.config.mode == "file": + elif self.mode == "file": await self._run_file_mode() else: - # auto模式：有TTY用交互，无TTY用socket import sys if sys.stdin.isatty(): @@ -126,15 +291,14 @@ async def _run_loop(self) -> None: await self.session_manager.stop_cleanup_task() async def _run_socket_mode(self) -> None: - """Socket模式""" platform_info = detect_platform() server = create_socket_server( platform_info, { - "socket_type": self.config.socket_type, - "socket_path": self.config.socket_path, - "tcp_host": self.config.tcp_host, - "tcp_port": self.config.tcp_port, + "socket_type": self.socket_type, + "socket_path": self.socket_path, + "tcp_host": self.tcp_host, + "tcp_port": self.tcp_port, }, self.token_manager.token, ) @@ -146,7 +310,7 @@ async def _run_socket_mode(self) -> None: platform_meta=self.metadata, output_queue=self._output_queue, event_committer=self.commit_event, - use_isolated_sessions=self.config.use_isolated_sessions, + use_isolated_sessions=self.use_isolated_sessions, data_path=get_astrbot_data_path(), ) @@ -160,7 +324,6 @@ async def _run_socket_mode(self) -> None: await self._handler.run() async def _run_tty_mode(self) -> None: - """TTY交互模式""" self._handler = TTYHandler( message_converter=self.message_converter, platform_meta=self.metadata, @@ -170,11 +333,10 @@ async def _run_tty_mode(self) -> None: await self._handler.run() async def _run_file_mode(self) -> None: - """文件轮询模式""" self._handler = FileHandler( - input_file=self.config.input_file, - output_file=self.config.output_file, - poll_interval=self.config.poll_interval, + input_file=self.input_file, + output_file=self.output_file, + poll_interval=self.poll_interval, message_converter=self.message_converter, platform_meta=self.metadata, output_queue=self._output_queue, @@ -187,20 +349,16 @@ async def send_by_session( session: MessageSesion, message_chain: MessageChain, ) -> None: - """通过会话发送消息""" await self._output_queue.put(message_chain) await super().send_by_session(session, message_chain) def meta(self) -> PlatformMetadata: - """获取平台元数据""" return self.metadata def unified_webhook(self) -> bool: - """CLI不使用webhook""" return False def get_stats(self) -> dict: - """获取平台统计信息（兼容CLIConfig数据类）""" meta = self.meta() meta_info = { "id": meta.id, @@ -211,7 +369,7 @@ def get_stats(self) -> dict: "support_proactive_message": meta.support_proactive_message, } return { - "id": meta.id or self.config.platform_id, + "id": meta.id or self.platform_id, "type": meta.name, "display_name": meta.adapter_display_name or meta.name, "status": self._status.value, @@ -229,7 +387,6 @@ def get_stats(self) -> dict: } async def terminate(self) -> None: - """终止平台运行""" self._running = False if self._handler: self._handler.stop() diff --git a/astrbot/core/platform/sources/cli/cli_event.py b/astrbot/core/platform/sources/cli/cli_event.py index 5fc82e4ed1..57c877ff52 100644 --- a/astrbot/core/platform/sources/cli/cli_event.py +++ b/astrbot/core/platform/sources/cli/cli_event.py @@ -1,31 +1,286 @@ -""" -CLI Message Event - CLI消息事件 +"""CLI消息事件模块 -处理CLI平台的消息事件，包括消息发送和接收。 -使用 ImageProcessor 处理图片，遵循 DRY 原则。 +处理CLI平台的消息事件、消息转换和图片处理。 """ import asyncio +import base64 +import os +import tempfile +import uuid from collections.abc import AsyncGenerator from typing import Any from astrbot import logger +from astrbot.core.message.components import Image, Plain from astrbot.core.message.message_event_result import MessageChain +from astrbot.core.platform import AstrBotMessage, MessageMember, MessageType from astrbot.core.platform.astr_message_event import AstrMessageEvent -from astrbot.core.platform.astrbot_message import AstrBotMessage from astrbot.core.platform.platform_metadata import PlatformMetadata +from astrbot.core.utils.astrbot_path import get_astrbot_temp_path + +# ------------------------------------------------------------------ +# 消息转换 +# ------------------------------------------------------------------ + + +class MessageConverter: + """将文本输入转换为AstrBotMessage对象""" + + def __init__( + self, + default_session_id: str = "cli_session", + user_id: str = "cli_user", + user_nickname: str = "CLI User", + ): + self.default_session_id = default_session_id + self.user_id = user_id + self.user_nickname = user_nickname + + def convert( + self, + text: str, + request_id: str | None = None, + use_isolated_session: bool = False, + ) -> AstrBotMessage: + """将文本转换为AstrBotMessage""" + message = AstrBotMessage() + message.self_id = "cli_bot" + message.message_str = text + message.message = [Plain(text)] + message.type = MessageType.FRIEND_MESSAGE + message.message_id = str(uuid.uuid4()) + + if use_isolated_session and request_id: + message.session_id = f"cli_session_{request_id}" + else: + message.session_id = self.default_session_id + + message.sender = MessageMember( + user_id=self.user_id, + nickname=self.user_nickname, + ) + message.raw_message = None + return message + -from .message.image_processor import ImageProcessor +# ------------------------------------------------------------------ +# 图片处理 +# ------------------------------------------------------------------ + + +def preprocess_chain(message_chain: MessageChain) -> None: + """预处理消息链：将本地文件图片转换为base64""" + for comp in message_chain.chain: + if isinstance(comp, Image) and comp.file and comp.file.startswith("file:///"): + file_path = comp.file[8:] + try: + if os.path.exists(file_path): + with open(file_path, "rb") as f: + data = f.read() + comp.file = f"base64://{base64.b64encode(data).decode('utf-8')}" + except Exception as e: + logger.error(f"[CLI] Failed to read image file {file_path}: {e}") + + +def extract_images(message_chain: MessageChain) -> list[dict]: + """从消息链提取图片信息，返回字典列表""" + images = [] + for comp in message_chain.chain: + if isinstance(comp, Image) and comp.file: + image_info = _process_image(comp.file) + images.append(image_info) + return images + + +def _process_image(file_ref: str) -> dict: + """处理单个图片引用，返回字典""" + if file_ref.startswith("http"): + return {"type": "url", "url": file_ref} + + if file_ref.startswith("file:///"): + return _process_local_file(file_ref[8:]) + + if file_ref.startswith("base64://"): + return _process_base64(file_ref[9:]) + + return {"type": "unknown"} + + +def _process_local_file(file_path: str) -> dict: + """处理本地文件""" + result: dict[str, Any] = {"type": "file", "path": file_path} + try: + if os.path.exists(file_path): + with open(file_path, "rb") as f: + data = f.read() + result["base64_data"] = base64.b64encode(data).decode("utf-8") + result["size"] = len(data) + else: + result["error"] = "Failed to read file" + except Exception as e: + result["error"] = str(e) + return result + + +def _process_base64(base64_data: str) -> dict: + """处理base64数据""" + try: + data = base64.b64decode(base64_data) + temp_dir = get_astrbot_temp_path() + os.makedirs(temp_dir, exist_ok=True) + temp_file = tempfile.NamedTemporaryFile( + delete=False, suffix=".png", dir=temp_dir + ) + temp_file.write(data) + temp_file.close() + return {"type": "file", "path": temp_file.name, "size": len(data)} + except Exception as e: + return {"type": "base64", "error": str(e)} + + +# ------------------------------------------------------------------ +# 向后兼容：ImageProcessor 和 ImageInfo +# ------------------------------------------------------------------ + + +class ImageInfo: + """图片信息（向后兼容）""" + + def __init__( + self, type: str, url=None, path=None, base64_data=None, size=None, error=None + ): + self.type = type + self.url = url + self.path = path + self.base64_data = base64_data + self.size = size + self.error = error + + def to_dict(self) -> dict: + result = {"type": self.type} + if self.url: + result["url"] = self.url + if self.path: + result["path"] = self.path + if self.base64_data: + result["base64_data"] = self.base64_data + if self.size: + result["size"] = self.size + if self.error: + result["error"] = self.error + return result + + +class ImageProcessor: + """图片处理器（向后兼容门面）""" + + @staticmethod + def local_file_to_base64(file_path: str) -> str | None: + try: + if os.path.exists(file_path): + with open(file_path, "rb") as f: + data = f.read() + return base64.b64encode(data).decode("utf-8") + except Exception as e: + logger.error(f"[CLI] Failed to read file {file_path}: {e}") + return None + + @staticmethod + def base64_to_temp_file(base64_data: str) -> str | None: + try: + data = base64.b64decode(base64_data) + temp_dir = get_astrbot_temp_path() + os.makedirs(temp_dir, exist_ok=True) + temp_file = tempfile.NamedTemporaryFile( + delete=False, suffix=".png", dir=temp_dir + ) + temp_file.write(data) + temp_file.close() + return temp_file.name + except Exception: + return None + + @staticmethod + def preprocess_chain(message_chain: MessageChain) -> None: + preprocess_chain(message_chain) + + @staticmethod + def extract_images(message_chain: MessageChain) -> list[ImageInfo]: + raw_images = extract_images(message_chain) + return [ + ImageInfo( + type=img.get("type", "unknown"), + url=img.get("url"), + path=img.get("path"), + base64_data=img.get("base64_data"), + size=img.get("size"), + error=img.get("error"), + ) + for img in raw_images + ] + + @staticmethod + def image_info_to_dict(image_info: ImageInfo) -> dict: + return image_info.to_dict() + + +# ------------------------------------------------------------------ +# 响应构建器（向后兼容） +# ------------------------------------------------------------------ + + +class ResponseBuilder: + """JSON响应构建器（向后兼容）""" + + @staticmethod + def build_success( + message_chain: MessageChain, + request_id: str, + extra: dict[str, Any] | None = None, + ) -> str: + import json + + response_text = message_chain.get_plain_text() + images = ImageProcessor.extract_images(message_chain) + result = { + "status": "success", + "response": response_text, + "images": [img.to_dict() for img in images], + "request_id": request_id, + } + if extra: + result.update(extra) + return json.dumps(result, ensure_ascii=False) + + @staticmethod + def build_error( + error_msg: str, + request_id: str | None = None, + error_code: str | None = None, + ) -> str: + import json + + result: dict[str, Any] = {"status": "error", "error": error_msg} + if request_id: + result["request_id"] = request_id + if error_code: + result["error_code"] = error_code + return json.dumps(result, ensure_ascii=False) + + +# ------------------------------------------------------------------ +# CLI消息事件 +# ------------------------------------------------------------------ class CLIMessageEvent(AstrMessageEvent): """CLI消息事件 - 处理命令行模拟器的消息事件。 Socket模式下收集管道中所有send()调用的消息，在管道完成(finalize)后统一返回。 """ - MAX_BUFFER_SIZE = 100 # 缓冲区最大消息组件数 + MAX_BUFFER_SIZE = 100 def __init__( self, @@ -36,27 +291,21 @@ def __init__( output_queue: asyncio.Queue, response_future: asyncio.Future = None, ): - """初始化CLI消息事件""" super().__init__( message_str=message_str, message_obj=message_obj, platform_meta=platform_meta, session_id=session_id, ) - self.output_queue = output_queue self.response_future = response_future - - # 多次回复收集（Socket模式） self.send_buffer = None async def send(self, message_chain: MessageChain) -> dict[str, Any]: - """发送消息到CLI""" await super().send(message_chain) - # Socket模式：收集所有回复到buffer，等待finalize()统一返回 if self.response_future is not None and not self.response_future.done(): - ImageProcessor.preprocess_chain(message_chain) + preprocess_chain(message_chain) if not self.send_buffer: self.send_buffer = message_chain @@ -66,10 +315,7 @@ async def send(self, message_chain: MessageChain) -> dict[str, Any]: new_size = len(message_chain.chain) if current_size + new_size > self.MAX_BUFFER_SIZE: logger.warning( - "[CLI] Buffer size limit reached (%d + %d > %d), truncating", - current_size, - new_size, - self.MAX_BUFFER_SIZE, + f"[CLI] Buffer size limit reached ({current_size} + {new_size} > {self.MAX_BUFFER_SIZE}), truncating" ) available = self.MAX_BUFFER_SIZE - current_size if available > 0: @@ -77,10 +323,9 @@ async def send(self, message_chain: MessageChain) -> dict[str, Any]: else: self.send_buffer.chain.extend(message_chain.chain) logger.debug( - "[CLI] Appended to buffer, total: %d", len(self.send_buffer.chain) + f"[CLI] Appended to buffer, total: {len(self.send_buffer.chain)}" ) else: - # 非Socket模式或future已完成：直接放入输出队列 await self.output_queue.put(message_chain) return {"success": True} @@ -90,11 +335,6 @@ async def send_streaming( generator: AsyncGenerator[MessageChain, None], use_fallback: bool = False, ) -> None: - """处理流式LLM响应 - - CLI不支持真正的流式输出，采用收集后一次性发送的策略。 - 与aiocqhttp的非fallback模式一致。 - """ buffer = None async for chain in generator: if not buffer: @@ -110,22 +350,15 @@ async def send_streaming( await super().send_streaming(generator, use_fallback) async def reply(self, message_chain: MessageChain) -> dict[str, Any]: - """回复消息""" return await self.send(message_chain) async def finalize(self) -> None: - """管道完成后调用，将收集的所有回复统一返回给Socket客户端。 - - 由PipelineScheduler.execute()在所有阶段执行完毕后调用。 - """ if self.response_future and not self.response_future.done(): if self.send_buffer: self.response_future.set_result(self.send_buffer) logger.debug( - "[CLI] Pipeline done, response set with %d components", - len(self.send_buffer.chain), + f"[CLI] Pipeline done, response set with {len(self.send_buffer.chain)} components" ) else: - # 管道完成但没有任何发送操作（如被白名单/频率限制拦截） self.response_future.set_result(None) logger.debug("[CLI] Pipeline done, no response to send") diff --git a/astrbot/core/platform/sources/cli/config/__init__.py b/astrbot/core/platform/sources/cli/config/__init__.py deleted file mode 100644 index d026e8ee9c..0000000000 --- a/astrbot/core/platform/sources/cli/config/__init__.py +++ /dev/null @@ -1,6 +0,0 @@ -"""CLI配置模块""" - -from .config_loader import ConfigLoader -from .token_manager import TokenManager - -__all__ = ["ConfigLoader", "TokenManager"] diff --git a/astrbot/core/platform/sources/cli/config/config_loader.py b/astrbot/core/platform/sources/cli/config/config_loader.py deleted file mode 100644 index 9a9da6efc5..0000000000 --- a/astrbot/core/platform/sources/cli/config/config_loader.py +++ /dev/null @@ -1,224 +0,0 @@ -"""CLI配置模块 - -拆分为单一职责的小组件： -- CLIConfig: 纯数据结构 -- PathResolver: 路径解析 -- ConfigFileReader: 配置文件读取 -- ConfigLoader: 组合门面 -""" - -import json -import os -from dataclasses import dataclass, field -from typing import Any - -from astrbot import logger -from astrbot.core.utils.astrbot_path import get_astrbot_data_path, get_astrbot_temp_path - -# ============================================================ -# 原子组件：路径解析器 -# ============================================================ - - -class PathResolver: - """路径解析器 - - 单一职责：解析和生成默认路径 - """ - - @staticmethod - def get_socket_path(custom_path: str = "") -> str: - """获取Socket路径""" - if custom_path: - return custom_path - return os.path.join(get_astrbot_temp_path(), "astrbot.sock") - - @staticmethod - def get_input_file(custom_path: str = "") -> str: - """获取输入文件路径""" - if custom_path: - return custom_path - return os.path.join(get_astrbot_temp_path(), "astrbot_cli", "input.txt") - - @staticmethod - def get_output_file(custom_path: str = "") -> str: - """获取输出文件路径""" - if custom_path: - return custom_path - return os.path.join(get_astrbot_temp_path(), "astrbot_cli", "output.txt") - - @staticmethod - def get_config_file_path(filename: str = "cli_config.json") -> str: - """获取配置文件路径""" - return os.path.join(get_astrbot_data_path(), filename) - - -# ============================================================ -# 原子组件：配置文件读取器 -# ============================================================ - - -class ConfigFileReader: - """配置文件读取器 - - 单一职责：读取JSON配置文件 - """ - - @staticmethod - def read(file_path: str) -> dict | None: - """读取配置文件 - - Args: - file_path: 配置文件路径 - - Returns: - 配置字典或None - """ - if not os.path.exists(file_path): - return None - - try: - with open(file_path, encoding="utf-8") as f: - config = json.load(f) - logger.info("Loaded config from %s", file_path) - return config - except Exception as e: - logger.warning("Failed to load config from %s: %s", file_path, e) - return None - - -# ============================================================ -# 数据结构：CLI配置 -# ============================================================ - - -@dataclass -class CLIConfig: - """CLI配置数据类 - - 纯数据结构，不包含业务逻辑 - """ - - # 运行模式 - mode: str = "socket" - socket_type: str = "auto" - socket_path: str = "" - tcp_host: str = "127.0.0.1" - tcp_port: int = 0 - - # 文件模式配置 - input_file: str = "" - output_file: str = "" - poll_interval: float = 1.0 - - # 会话配置 - use_isolated_sessions: bool = False - session_ttl: int = 30 - - # 其他 - whitelist: list[str] = field(default_factory=list) - platform_id: str = "cli" - - -# ============================================================ -# 组合组件：配置构建器 -# ============================================================ - - -class ConfigBuilder: - """配置构建器 - - 从字典构建CLIConfig，处理默认值 - """ - - @staticmethod - def build(config_dict: dict[str, Any]) -> CLIConfig: - """从字典构建配置""" - return CLIConfig( - mode=config_dict.get("mode", "socket"), - socket_type=config_dict.get("socket_type", "auto"), - socket_path=PathResolver.get_socket_path( - config_dict.get("socket_path", "") - ), - tcp_host=config_dict.get("tcp_host", "127.0.0.1"), - tcp_port=config_dict.get("tcp_port", 0), - input_file=PathResolver.get_input_file(config_dict.get("input_file", "")), - output_file=PathResolver.get_output_file( - config_dict.get("output_file", "") - ), - poll_interval=config_dict.get("poll_interval", 1.0), - use_isolated_sessions=config_dict.get("use_isolated_sessions", False), - session_ttl=config_dict.get("session_ttl", 30), - whitelist=config_dict.get("whitelist", []), - platform_id=config_dict.get("id", "cli"), - ) - - -# ============================================================ -# 组合组件：配置合并器 -# ============================================================ - - -class ConfigMerger: - """配置合并器 - - 合并多个配置源 - """ - - @staticmethod - def merge(base: dict, override: dict | None) -> dict: - """合并配置，override优先""" - if override is None: - return base.copy() - - result = base.copy() - result.update(override) - return result - - -# ============================================================ -# 门面：配置加载器 -# ============================================================ - - -class ConfigLoader: - """配置加载器门面 - - 组合所有小组件，提供统一接口 - - I/O契约: - Input: platform_config (dict), platform_settings (dict) - Output: CLIConfig - """ - - @staticmethod - def load( - platform_config: dict[str, Any], - platform_settings: dict[str, Any] | None = None, - ) -> CLIConfig: - """加载CLI配置 - - 优先级: 独立配置文件 > platform_config > 默认值 - - Args: - platform_config: 平台配置字典 - platform_settings: 平台设置字典 - - Returns: - CLIConfig实例 - """ - # 尝试从独立配置文件加载 - config_filename = platform_config.get("config_file", "cli_config.json") - config_path = PathResolver.get_config_file_path(config_filename) - - file_config = ConfigFileReader.read(config_path) - - # 合并配置 - if file_config: - if "platform_config" in file_config: - platform_config = ConfigMerger.merge( - platform_config, file_config["platform_config"] - ) - - # 构建最终配置 - return ConfigBuilder.build(platform_config) diff --git a/astrbot/core/platform/sources/cli/config/token_manager.py b/astrbot/core/platform/sources/cli/config/token_manager.py deleted file mode 100644 index e2708e7fe8..0000000000 --- a/astrbot/core/platform/sources/cli/config/token_manager.py +++ /dev/null @@ -1,99 +0,0 @@ -"""Token管理器 - -负责认证Token的生成、读取和验证。 -""" - -import os -import secrets - -from astrbot import logger -from astrbot.core.utils.astrbot_path import get_astrbot_data_path - - -class TokenManager: - """Token管理器 - - I/O契约: - Input: None - Output: token (str | None) - """ - - TOKEN_FILE = ".cli_token" - - def __init__(self): - """初始化Token管理器""" - self._token: str | None = None - self._token_file = os.path.join(get_astrbot_data_path(), self.TOKEN_FILE) - - @property - def token(self) -> str | None: - """获取当前Token""" - if self._token is None: - self._token = self._ensure_token() - return self._token - - def _ensure_token(self) -> str | None: - """确保Token存在，不存在则自动生成 - - Returns: - Token字符串或None - """ - try: - # 如果token文件已存在，直接读取 - if os.path.exists(self._token_file): - with open(self._token_file, encoding="utf-8") as f: - token = f.read().strip() - - if token: - logger.info("Authentication token loaded from file") - return token - else: - logger.warning("Token file is empty, regenerating") - - # 首次启动或token为空，自动生成新token - token = secrets.token_urlsafe(32) - - # 写入文件 - with open(self._token_file, "w", encoding="utf-8") as f: - f.write(token) - - # 设置严格权限（仅所有者可读写） - try: - os.chmod(self._token_file, 0o600) - except OSError: - # Windows可能不支持chmod - pass - - logger.info("Generated new authentication token: %s", token) - logger.info("Token saved to: %s", self._token_file) - return token - - except Exception as e: - logger.error("Failed to ensure token: %s", e) - logger.warning("Authentication disabled due to token error") - return None - - def validate(self, provided_token: str) -> bool: - """验证提供的Token - - Args: - provided_token: 待验证的Token - - Returns: - 验证是否通过 - """ - if not self.token: - # 无Token时跳过验证 - return True - - if not provided_token: - logger.warning("Request rejected: missing auth_token") - return False - - if provided_token != self.token: - logger.warning( - "Request rejected: invalid auth_token (length=%d)", len(provided_token) - ) - return False - - return True diff --git a/astrbot/core/platform/sources/cli/connection_info_writer.py b/astrbot/core/platform/sources/cli/connection_info_writer.py deleted file mode 100644 index 395a8281d1..0000000000 --- a/astrbot/core/platform/sources/cli/connection_info_writer.py +++ /dev/null @@ -1,120 +0,0 @@ -"""ConnectionInfoWriter - 连接信息写入器 - -将Socket连接信息写入JSON文件，供客户端读取。 -遵循Unix哲学：原子化操作、显式I/O、无副作用。 -""" - -import json -import os -import tempfile -from typing import Any - -from astrbot import logger - - -def write_connection_info(connection_info: dict[str, Any], data_dir: str) -> None: - """写入连接信息到文件 - - I/O契约: - Input: - connection_info: Socket连接信息 - - type: "unix" | "tcp" - - path: str (Unix Socket) - - host: str (TCP Socket) - - port: int (TCP Socket) - data_dir: 数据目录路径 - Output: None (副作用: 写入到 {data_dir}/.cli_connection) - - Args: - connection_info: 连接信息字典 - data_dir: 数据目录路径 - - Raises: - ValueError: 连接信息格式无效 - OSError: 文件写入失败 - """ - logger.info( - "[ENTRY] write_connection_info inputs={info=%s, dir=%s}", - connection_info, - data_dir, - ) - - # 验证输入 - _validate_connection_info(connection_info) - - # 目标文件路径 - target_path = os.path.join(data_dir, ".cli_connection") - logger.debug("[PROCESS] Target file: %s", target_path) - - # 原子写入：先写临时文件，再重命名 - try: - # 创建临时文件（同目录，确保原子重命名） - fd, temp_path = tempfile.mkstemp( - dir=data_dir, prefix=".cli_connection.", suffix=".tmp" - ) - logger.debug("[PROCESS] Created temp file: %s", temp_path) - - try: - # 写入JSON数据 - with os.fdopen(fd, "w", encoding="utf-8") as f: - json.dump(connection_info, f, indent=2) - logger.debug("[PROCESS] JSON data written to temp file") - - # 尝试设置文件权限（Windows下尽力而为） - _set_file_permissions(temp_path) - - # 原子重命名 - os.replace(temp_path, target_path) - logger.info("[PROCESS] Atomic rename completed: %s", target_path) - - except Exception: - # 清理临时文件 - if os.path.exists(temp_path): - os.remove(temp_path) - logger.debug("[PROCESS] Cleaned up temp file: %s", temp_path) - raise - - except Exception as e: - logger.error("[ERROR] Failed to write connection info: %s", e) - raise - - logger.info("[EXIT] write_connection_info return=None") - - -def _validate_connection_info(connection_info: dict[str, Any]) -> None: - """验证连接信息格式 - - Args: - connection_info: 连接信息字典 - - Raises: - ValueError: 格式无效 - """ - if not isinstance(connection_info, dict): - raise ValueError("connection_info must be a dict") - - conn_type = connection_info.get("type") - if conn_type not in ("unix", "tcp"): - raise ValueError(f"Invalid type: {conn_type}, must be 'unix' or 'tcp'") - - if conn_type == "unix": - if "path" not in connection_info: - raise ValueError("Unix socket requires 'path' field") - elif conn_type == "tcp": - if "host" not in connection_info or "port" not in connection_info: - raise ValueError("TCP socket requires 'host' and 'port' fields") - - -def _set_file_permissions(file_path: str) -> None: - """设置文件权限（Windows下尽力而为） - - Args: - file_path: 文件路径 - """ - try: - # Unix/Linux: 设置600权限 - os.chmod(file_path, 0o600) - logger.debug("[SECURITY] File permissions set to 600: %s", file_path) - except (OSError, NotImplementedError) as e: - # Windows可能不支持chmod，记录警告但不失败 - logger.warning("[SECURITY] Failed to set file permissions (Windows?): %s", e) diff --git a/astrbot/core/platform/sources/cli/handlers/file_handler.py b/astrbot/core/platform/sources/cli/file_handler.py similarity index 77% rename from astrbot/core/platform/sources/cli/handlers/file_handler.py rename to astrbot/core/platform/sources/cli/file_handler.py index d10fee2c0a..87f50a3821 100644 --- a/astrbot/core/platform/sources/cli/handlers/file_handler.py +++ b/astrbot/core/platform/sources/cli/file_handler.py @@ -1,7 +1,4 @@ -"""文件轮询模式处理器 - -负责处理文件轮询模式的输入输出。 -""" +"""文件轮询模式处理器""" import asyncio import datetime @@ -12,35 +9,25 @@ from astrbot import logger from astrbot.core.message.message_event_result import MessageChain -from ..interfaces import IHandler, IMessageConverter - if TYPE_CHECKING: from astrbot.core.platform.platform_metadata import PlatformMetadata - from ..cli_event import CLIMessageEvent - + from .cli_event import CLIMessageEvent -class FileHandler(IHandler): - """文件轮询模式处理器 - 实现IHandler接口，提供文件I/O功能。 - - I/O契约: - Input: 输入文件内容 - Output: None (写入输出文件) - """ +class FileHandler: + """文件轮询模式处理器""" def __init__( self, input_file: str, output_file: str, poll_interval: float, - message_converter: IMessageConverter, + message_converter, platform_meta: "PlatformMetadata", output_queue: asyncio.Queue, event_committer: Callable[["CLIMessageEvent"], None], ): - """初始化文件处理器""" self.input_file = input_file self.output_file = output_file self.poll_interval = poll_interval @@ -51,14 +38,13 @@ def __init__( self._running = False async def run(self) -> None: - """运行文件轮询模式""" self._running = True self._ensure_directories() - - logger.info("File mode: input=%s, output=%s", self.input_file, self.output_file) + logger.info( + f"[CLI] File mode: input={self.input_file}, output={self.output_file}" + ) output_task = asyncio.create_task(self._output_loop()) - try: await self._poll_loop() finally: @@ -70,59 +56,44 @@ async def run(self) -> None: pass def stop(self) -> None: - """停止文件模式""" self._running = False def _ensure_directories(self) -> None: - """确保目录存在""" for path in (self.input_file, self.output_file): dir_path = os.path.dirname(path) if dir_path: os.makedirs(dir_path, exist_ok=True) - if not os.path.exists(self.input_file): with open(self.input_file, "w") as f: f.write("") async def _poll_loop(self) -> None: - """轮询循环""" while self._running: commands = self._read_commands() - for cmd in commands: if cmd: await self._handle_command(cmd) - await asyncio.sleep(self.poll_interval) def _read_commands(self) -> list[str]: - """读取并清空输入文件""" try: if not os.path.exists(self.input_file): return [] - with open(self.input_file, encoding="utf-8") as f: content = f.read().strip() - if not content: return [] - - # 清空输入文件 with open(self.input_file, "w", encoding="utf-8") as f: f.write("") - return [line.strip() for line in content.split("\n") if line.strip()] - except Exception as e: - logger.error("Failed to read input file: %s", e) + logger.error(f"[CLI] Failed to read input file: {e}") return [] async def _handle_command(self, text: str) -> None: - """处理命令""" - from ..cli_event import CLIMessageEvent + from .cli_event import CLIMessageEvent message = self.message_converter.convert(text) - message_event = CLIMessageEvent( message_str=message.message_str, message_obj=message, @@ -130,11 +101,9 @@ async def _handle_command(self, text: str) -> None: session_id=message.session_id, output_queue=self.output_queue, ) - self.event_committer(message_event) async def _output_loop(self) -> None: - """输出循环""" while self._running: try: message_chain = await asyncio.wait_for( @@ -147,13 +116,10 @@ async def _output_loop(self) -> None: break def _write_response(self, message_chain: MessageChain) -> None: - """写入响应到文件""" try: text = message_chain.get_plain_text() timestamp = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S") - with open(self.output_file, "a", encoding="utf-8") as f: f.write(f"[{timestamp}] Bot: {text}\n") - except Exception as e: - logger.error("Failed to write output file: %s", e) + logger.error(f"[CLI] Failed to write output file: {e}") diff --git a/astrbot/core/platform/sources/cli/handlers/__init__.py b/astrbot/core/platform/sources/cli/handlers/__init__.py deleted file mode 100644 index b4b9d0b409..0000000000 --- a/astrbot/core/platform/sources/cli/handlers/__init__.py +++ /dev/null @@ -1,7 +0,0 @@ -"""CLI处理器模块""" - -from .file_handler import FileHandler -from .socket_handler import SocketClientHandler, SocketModeHandler -from .tty_handler import TTYHandler - -__all__ = ["SocketClientHandler", "SocketModeHandler", "TTYHandler", "FileHandler"] diff --git a/astrbot/core/platform/sources/cli/interfaces.py b/astrbot/core/platform/sources/cli/interfaces.py deleted file mode 100644 index 8ef2a9a959..0000000000 --- a/astrbot/core/platform/sources/cli/interfaces.py +++ /dev/null @@ -1,91 +0,0 @@ -"""CLI核心接口定义 - -定义CLI模块的核心抽象接口，遵循依赖倒置原则。 -所有具体实现依赖于这些接口，而非具体实现。 -""" - -from abc import ABC, abstractmethod -from typing import Any, Protocol, runtime_checkable - -from astrbot.core.message.message_event_result import MessageChain - - -@runtime_checkable -class ITokenValidator(Protocol): - """Token验证器接口""" - - def validate(self, token: str) -> bool: - """验证Token""" - ... - - -@runtime_checkable -class IMessageConverter(Protocol): - """消息转换器接口""" - - def convert( - self, - text: str, - request_id: str | None = None, - use_isolated_session: bool = False, - ) -> Any: - """将文本转换为消息对象""" - ... - - -@runtime_checkable -class ISessionManager(Protocol): - """会话管理器接口""" - - def register(self, session_id: str) -> None: - """注册会话""" - ... - - def touch(self, session_id: str) -> None: - """更新会话时间戳""" - ... - - def is_expired(self, session_id: str) -> bool: - """检查会话是否过期""" - ... - - -class IHandler(ABC): - """处理器抽象基类 - - 所有模式处理器（Socket/TTY/File）的共同接口。 - """ - - @abstractmethod - async def run(self) -> None: - """运行处理器""" - pass - - @abstractmethod - def stop(self) -> None: - """停止处理器""" - pass - - -class IResponseBuilder(Protocol): - """响应构建器接口""" - - def build_success(self, message_chain: MessageChain, request_id: str) -> str: - """构建成功响应""" - ... - - def build_error(self, error_msg: str, request_id: str | None = None) -> str: - """构建错误响应""" - ... - - -class IImageProcessor(Protocol): - """图片处理器接口""" - - def preprocess_chain(self, message_chain: MessageChain) -> None: - """预处理消息链中的图片""" - ... - - def extract_images(self, message_chain: MessageChain) -> list[Any]: - """从消息链中提取图片信息""" - ... diff --git a/astrbot/core/platform/sources/cli/message/__init__.py b/astrbot/core/platform/sources/cli/message/__init__.py deleted file mode 100644 index 42e4671761..0000000000 --- a/astrbot/core/platform/sources/cli/message/__init__.py +++ /dev/null @@ -1,14 +0,0 @@ -"""CLI消息处理模块""" - -from .converter import MessageConverter -from .image_processor import ImageInfo, ImageProcessor -from .response_builder import ResponseBuilder -from .response_collector import ResponseCollector - -__all__ = [ - "MessageConverter", - "ImageProcessor", - "ImageInfo", - "ResponseCollector", - "ResponseBuilder", -] diff --git a/astrbot/core/platform/sources/cli/message/converter.py b/astrbot/core/platform/sources/cli/message/converter.py deleted file mode 100644 index aaddc5bfa4..0000000000 --- a/astrbot/core/platform/sources/cli/message/converter.py +++ /dev/null @@ -1,76 +0,0 @@ -"""消息转换器 - -负责将文本输入转换为AstrBotMessage对象。 -""" - -import uuid - -from astrbot import logger -from astrbot.core.message.components import Plain -from astrbot.core.platform import AstrBotMessage, MessageMember, MessageType - - -class MessageConverter: - """消息转换器 - - I/O契约: - Input: text (str), request_id (str | None) - Output: AstrBotMessage - """ - - def __init__( - self, - default_session_id: str = "cli_session", - user_id: str = "cli_user", - user_nickname: str = "CLI User", - ): - """初始化消息转换器 - - Args: - default_session_id: 默认会话ID - user_id: 用户ID - user_nickname: 用户昵称 - """ - self.default_session_id = default_session_id - self.user_id = user_id - self.user_nickname = user_nickname - - def convert( - self, - text: str, - request_id: str | None = None, - use_isolated_session: bool = False, - ) -> AstrBotMessage: - """将文本转换为AstrBotMessage - - Args: - text: 原始文本 - request_id: 请求ID（用于会话隔离） - use_isolated_session: 是否使用隔离会话 - - Returns: - AstrBotMessage对象 - """ - logger.debug("Converting input: text=%s, request_id=%s", text, request_id) - - message = AstrBotMessage() - message.self_id = "cli_bot" - message.message_str = text - message.message = [Plain(text)] - message.type = MessageType.FRIEND_MESSAGE - message.message_id = str(uuid.uuid4()) - - # 根据配置决定会话ID - if use_isolated_session and request_id: - message.session_id = f"cli_session_{request_id}" - else: - message.session_id = self.default_session_id - - message.sender = MessageMember( - user_id=self.user_id, - nickname=self.user_nickname, - ) - - message.raw_message = None - - return message diff --git a/astrbot/core/platform/sources/cli/message/image_processor.py b/astrbot/core/platform/sources/cli/message/image_processor.py deleted file mode 100644 index 1b6f28f935..0000000000 --- a/astrbot/core/platform/sources/cli/message/image_processor.py +++ /dev/null @@ -1,247 +0,0 @@ -"""图片处理模块 - -拆分为单一职责的小组件： -- ImageCodec: base64编解码 -- ImageFileIO: 文件读写 -- ImageExtractor: 从消息链提取图片 -- ImageInfo: 数据结构 -""" - -import base64 -import os -import tempfile -from dataclasses import dataclass - -from astrbot import logger -from astrbot.core.message.components import Image -from astrbot.core.message.message_event_result import MessageChain -from astrbot.core.utils.astrbot_path import get_astrbot_temp_path - -# ============================================================ -# 数据结构 -# ============================================================ - - -@dataclass -class ImageInfo: - """图片信息数据结构""" - - type: str # "url", "file", "base64" - url: str | None = None - path: str | None = None - base64_data: str | None = None - size: int | None = None - error: str | None = None - - def to_dict(self) -> dict: - """转换为字典""" - result = {"type": self.type} - if self.url: - result["url"] = self.url - if self.path: - result["path"] = self.path - if self.base64_data: - result["base64_data"] = self.base64_data - if self.size: - result["size"] = self.size - if self.error: - result["error"] = self.error - return result - - -# ============================================================ -# 原子组件：Base64编解码 -# ============================================================ - - -class ImageCodec: - """Base64编解码器 - - 单一职责：仅负责base64编解码 - """ - - @staticmethod - def encode(data: bytes) -> str: - """编码为base64""" - return base64.b64encode(data).decode("utf-8") - - @staticmethod - def decode(base64_str: str) -> bytes: - """解码base64""" - return base64.b64decode(base64_str) - - -# ============================================================ -# 原子组件：文件I/O -# ============================================================ - - -class ImageFileIO: - """图片文件I/O - - 单一职责：仅负责文件读写 - """ - - @staticmethod - def read(file_path: str) -> bytes | None: - """读取文件""" - try: - if os.path.exists(file_path): - with open(file_path, "rb") as f: - return f.read() - except Exception as e: - logger.error("Failed to read file %s: %s", file_path, e) - return None - - @staticmethod - def write_temp(data: bytes, suffix: str = ".png") -> str | None: - """写入临时文件""" - try: - temp_dir = get_astrbot_temp_path() - os.makedirs(temp_dir, exist_ok=True) - - temp_file = tempfile.NamedTemporaryFile( - delete=False, - suffix=suffix, - dir=temp_dir, - ) - temp_file.write(data) - temp_file.close() - return temp_file.name - except Exception as e: - logger.error("Failed to write temp file: %s", e) - return None - - -# ============================================================ -# 组合组件：图片提取器 -# ============================================================ - - -class ImageExtractor: - """图片提取器 - - 组合ImageCodec和ImageFileIO，从消息链提取图片信息 - """ - - @staticmethod - def extract(message_chain: MessageChain) -> list[ImageInfo]: - """从消息链提取图片信息""" - images = [] - - for comp in message_chain.chain: - if isinstance(comp, Image) and comp.file: - image_info = ImageExtractor._process_image(comp.file) - images.append(image_info) - - return images - - @staticmethod - def _process_image(file_ref: str) -> ImageInfo: - """处理单个图片引用""" - if file_ref.startswith("http"): - return ImageInfo(type="url", url=file_ref) - - elif file_ref.startswith("file:///"): - return ImageExtractor._process_local_file(file_ref[8:]) - - elif file_ref.startswith("base64://"): - return ImageExtractor._process_base64(file_ref[9:]) - - return ImageInfo(type="unknown") - - @staticmethod - def _process_local_file(file_path: str) -> ImageInfo: - """处理本地文件""" - info = ImageInfo(type="file", path=file_path) - - data = ImageFileIO.read(file_path) - if data: - info.base64_data = ImageCodec.encode(data) - info.size = len(data) - else: - info.error = "Failed to read file" - - return info - - @staticmethod - def _process_base64(base64_data: str) -> ImageInfo: - """处理base64数据""" - try: - data = ImageCodec.decode(base64_data) - temp_path = ImageFileIO.write_temp(data) - - if temp_path: - return ImageInfo(type="file", path=temp_path, size=len(data)) - else: - return ImageInfo(type="base64", error="Failed to save to temp file") - except Exception as e: - return ImageInfo(type="base64", error=str(e)) - - -# ============================================================ -# 组合组件：消息链预处理器 -# ============================================================ - - -class ChainPreprocessor: - """消息链预处理器 - - 将消息链中的本地文件图片转换为base64 - """ - - @staticmethod - def preprocess(message_chain: MessageChain) -> None: - """预处理消息链（原地修改）""" - for comp in message_chain.chain: - if ( - isinstance(comp, Image) - and comp.file - and comp.file.startswith("file:///") - ): - file_path = comp.file[8:] - data = ImageFileIO.read(file_path) - if data: - comp.file = f"base64://{ImageCodec.encode(data)}" - - -# ============================================================ -# 向后兼容：ImageProcessor门面 -# ============================================================ - - -class ImageProcessor: - """图片处理器门面（向后兼容） - - 组合所有小组件，提供统一接口 - """ - - @staticmethod - def local_file_to_base64(file_path: str) -> str | None: - """将本地文件转换为base64""" - data = ImageFileIO.read(file_path) - return ImageCodec.encode(data) if data else None - - @staticmethod - def base64_to_temp_file(base64_data: str) -> str | None: - """将base64保存到临时文件""" - try: - data = ImageCodec.decode(base64_data) - return ImageFileIO.write_temp(data) - except Exception: - return None - - @staticmethod - def preprocess_chain(message_chain: MessageChain) -> None: - """预处理消息链""" - ChainPreprocessor.preprocess(message_chain) - - @staticmethod - def extract_images(message_chain: MessageChain) -> list[ImageInfo]: - """提取图片信息""" - return ImageExtractor.extract(message_chain) - - @staticmethod - def image_info_to_dict(image_info: ImageInfo) -> dict: - """转换为字典""" - return image_info.to_dict() diff --git a/astrbot/core/platform/sources/cli/message/response_builder.py b/astrbot/core/platform/sources/cli/message/response_builder.py deleted file mode 100644 index b07a8c49dd..0000000000 --- a/astrbot/core/platform/sources/cli/message/response_builder.py +++ /dev/null @@ -1,84 +0,0 @@ -"""JSON响应构建器 - -负责构建统一格式的JSON响应，与业务逻辑解耦。 -""" - -import json -from typing import Any - -from astrbot.core.message.message_event_result import MessageChain - -from .image_processor import ImageInfo, ImageProcessor - - -class ResponseBuilder: - """JSON响应构建器 - - I/O契约: - Input: MessageChain 或 error_msg - Output: JSON字符串 - """ - - @staticmethod - def build_success( - message_chain: MessageChain, - request_id: str, - extra: dict[str, Any] | None = None, - ) -> str: - """构建成功响应 - - Args: - message_chain: 消息链 - request_id: 请求ID - extra: 额外字段 - - Returns: - JSON字符串 - """ - response_text = message_chain.get_plain_text() - images = ImageProcessor.extract_images(message_chain) - - result = { - "status": "success", - "response": response_text, - "images": [ResponseBuilder._image_to_dict(img) for img in images], - "request_id": request_id, - } - - if extra: - result.update(extra) - - return json.dumps(result, ensure_ascii=False) - - @staticmethod - def build_error( - error_msg: str, - request_id: str | None = None, - error_code: str | None = None, - ) -> str: - """构建错误响应 - - Args: - error_msg: 错误消息 - request_id: 请求ID - error_code: 错误代码 - - Returns: - JSON字符串 - """ - result = { - "status": "error", - "error": error_msg, - } - - if request_id: - result["request_id"] = request_id - if error_code: - result["error_code"] = error_code - - return json.dumps(result, ensure_ascii=False) - - @staticmethod - def _image_to_dict(image_info: ImageInfo) -> dict: - """将ImageInfo转换为字典""" - return ImageProcessor.image_info_to_dict(image_info) diff --git a/astrbot/core/platform/sources/cli/message/response_collector.py b/astrbot/core/platform/sources/cli/message/response_collector.py deleted file mode 100644 index 65a09bd30f..0000000000 --- a/astrbot/core/platform/sources/cli/message/response_collector.py +++ /dev/null @@ -1,104 +0,0 @@ -"""响应收集器 - -负责收集多次回复并延迟返回，支持工具调用等多轮场景。 -""" - -import asyncio - -from astrbot import logger -from astrbot.core.message.message_event_result import MessageChain - -from .image_processor import ImageProcessor - - -class ResponseCollector: - """响应收集器 - - I/O契约: - Input: MessageChain (多次) - Output: MessageChain (合并后) - """ - - # 延迟配置 - INITIAL_DELAY = 5.0 # 首次回复延迟 - EXTENDED_DELAY = 10.0 # 后续回复延迟 - - def __init__(self, response_future: asyncio.Future): - """初始化响应收集器 - - Args: - response_future: 响应Future对象 - """ - self.response_future = response_future - self.buffer: MessageChain | None = None - self._delay_task: asyncio.Task | None = None - self._current_delay = self.INITIAL_DELAY - - def collect(self, message_chain: MessageChain) -> None: - """收集消息到缓冲区 - - Args: - message_chain: 消息链 - """ - if self.response_future.done(): - logger.warning("Response future already done, skipping collect") - return - - # 预处理图片 - ImageProcessor.preprocess_chain(message_chain) - - if not self.buffer: - # 首次收集 - self.buffer = message_chain - self._current_delay = self.INITIAL_DELAY - logger.info( - "First collect: initialized buffer with %.1fs delay", - self._current_delay, - ) - else: - # 追加到缓冲区 - self.buffer.chain.extend(message_chain.chain) - self._current_delay = self.EXTENDED_DELAY - logger.info( - "Appended to buffer (switched to %.1fs delay), total: %d components", - self._current_delay, - len(self.buffer.chain), - ) - - # 重置延迟任务 - self._reset_delay_task() - - def _reset_delay_task(self) -> None: - """重置延迟任务""" - # 取消之前的延迟任务 - if self._delay_task and not self._delay_task.done(): - self._delay_task.cancel() - logger.debug("Cancelled previous delay task") - - # 启动新的延迟任务 - self._delay_task = asyncio.create_task(self._delayed_response()) - logger.debug("Started new delay task (%.1fs)", self._current_delay) - - async def _delayed_response(self) -> None: - """延迟响应：等待一段时间后统一返回""" - try: - await asyncio.sleep(self._current_delay) - - if self.response_future and not self.response_future.done(): - self.response_future.set_result(self.buffer) - logger.debug( - "Set delayed response with %d components", - len(self.buffer.chain) if self.buffer else 0, - ) - else: - logger.warning( - "Response future already done or None, skipping set_result" - ) - - except asyncio.CancelledError: - # 被取消是正常的（有新消息到来） - pass - except Exception as e: - logger.error("Failed to set delayed response: %s", e) - if self.response_future and not self.response_future.done(): - self.response_future.set_exception(e) diff --git a/astrbot/core/platform/sources/cli/platform_detector.py b/astrbot/core/platform/sources/cli/platform_detector.py deleted file mode 100644 index a6bf09d16d..0000000000 --- a/astrbot/core/platform/sources/cli/platform_detector.py +++ /dev/null @@ -1,255 +0,0 @@ -""" -Platform Detector Module - -Detects the current operating system, Python version, and Unix Socket support. -Follows Unix philosophy: single responsibility, pure function, explicit I/O. - -Architecture: - Input: None - Output: PlatformInfo(os_type, python_version, supports_unix_socket) - -Data Flow: - [Start] -> detect_platform() - -> [Detect OS] platform.system() - -> [Detect Python Version] sys.version_info - -> [Check Unix Socket Support] - -> [Return] PlatformInfo -""" - -import platform -import sys -import time -from dataclasses import dataclass -from typing import Literal - -from astrbot import logger - - -@dataclass -class PlatformInfo: - """Platform information dataclass - - Attributes: - os_type: Operating system type (windows, linux, darwin) - python_version: Python version tuple (major, minor, micro) - supports_unix_socket: Whether Unix Socket is supported - """ - - os_type: Literal["windows", "linux", "darwin"] - python_version: tuple[int, int, int] - supports_unix_socket: bool - - -def _detect_os_type() -> Literal["windows", "linux", "darwin"]: - """Detect operating system type - - Returns: - OS type string: "windows", "linux", or "darwin" - Unknown systems default to "linux" (Unix-like fallback) - """ - start_time = time.time() - logger.debug("[ENTRY] _detect_os_type inputs={}") - - system = platform.system() - logger.debug(f"[PROCESS] platform.system() returned: {system}") - - # Normalize OS type - if system == "Windows": - os_type = "windows" - elif system == "Linux": - os_type = "linux" - elif system == "Darwin": - os_type = "darwin" - else: - # Unknown OS, default to linux (Unix-like fallback) - logger.warning(f"[PROCESS] Unknown OS type: {system}, defaulting to linux") - os_type = "linux" - - duration_ms = (time.time() - start_time) * 1000 - logger.debug(f"[EXIT] _detect_os_type return={os_type} time_ms={duration_ms:.2f}") - - return os_type - - -def _detect_python_version() -> tuple[int, int, int]: - """Detect Python version - - Returns: - Python version tuple (major, minor, micro) - """ - start_time = time.time() - logger.debug("[ENTRY] _detect_python_version inputs={}") - - # Handle both sys.version_info object and tuple (for testing) - version_info = sys.version_info - if hasattr(version_info, "major"): - # Normal sys.version_info object - version = (version_info.major, version_info.minor, version_info.micro) - else: - # Tuple (used in tests with mock.patch) - version = (version_info[0], version_info[1], version_info[2]) - - duration_ms = (time.time() - start_time) * 1000 - logger.debug( - f"[EXIT] _detect_python_version return={version} time_ms={duration_ms:.2f}" - ) - - return version - - -def _check_windows_unix_socket_support(python_version: tuple[int, int, int]) -> bool: - """Check if Windows supports Unix Socket - - Requirements: - - Python 3.9+ - - Windows 10 build 17063+ - - Uses actual socket creation test as primary method (most reliable). - - Args: - python_version: Python version tuple - - Returns: - True if Unix Socket is supported, False otherwise - """ - import socket - - start_time = time.time() - logger.debug( - f"[ENTRY] _check_windows_unix_socket_support inputs={{python_version={python_version}}}" - ) - - # Check Python version (must be 3.9+) - if python_version < (3, 9, 0): - logger.debug( - f"[PROCESS] Python version {python_version} < 3.9.0, Unix Socket not supported" - ) - duration_ms = (time.time() - start_time) * 1000 - logger.debug( - f"[EXIT] _check_windows_unix_socket_support return=False time_ms={duration_ms:.2f}" - ) - return False - - # 方法1：实际尝试创建 Unix Socket（最可靠） - try: - if hasattr(socket, "AF_UNIX"): - test_sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM) - test_sock.close() - logger.debug("[PROCESS] Unix Socket creation test passed") - duration_ms = (time.time() - start_time) * 1000 - logger.debug( - f"[EXIT] _check_windows_unix_socket_support return=True time_ms={duration_ms:.2f}" - ) - return True - except (OSError, AttributeError) as e: - logger.debug(f"[PROCESS] Unix Socket creation test failed: {e}") - - # 方法2：检查 Windows 版本号（备选，仅用于日志） - try: - win_ver = platform.win32_ver() - logger.debug(f"[PROCESS] platform.win32_ver() returned: {win_ver}") - - version_str = win_ver[1] - if version_str: - parts = version_str.split(".") - if len(parts) >= 3: - build = int(parts[2]) - logger.debug(f"[PROCESS] Windows build number: {build}") - if build >= 17063: - logger.debug( - f"[PROCESS] Build {build} >= 17063, but socket test failed" - ) - except Exception as e: - logger.debug(f"[PROCESS] Failed to check Windows version: {e}") - - duration_ms = (time.time() - start_time) * 1000 - logger.debug( - f"[EXIT] _check_windows_unix_socket_support return=False time_ms={duration_ms:.2f}" - ) - return False - - -def _check_unix_socket_support( - os_type: Literal["windows", "linux", "darwin"], python_version: tuple[int, int, int] -) -> bool: - """Check if Unix Socket is supported on current platform - - Logic: - - Linux/Darwin: Always supported - - Windows: Requires Python 3.9+ and Windows 10 build 17063+ - - Args: - os_type: Operating system type - python_version: Python version tuple - - Returns: - True if Unix Socket is supported, False otherwise - """ - start_time = time.time() - logger.debug( - f"[ENTRY] _check_unix_socket_support inputs={{os_type={os_type}, python_version={python_version}}}" - ) - - if os_type in ("linux", "darwin"): - logger.debug(f"[PROCESS] OS type {os_type} always supports Unix Socket") - supports = True - elif os_type == "windows": - logger.debug("[PROCESS] Checking Windows Unix Socket support") - supports = _check_windows_unix_socket_support(python_version) - else: - # Unknown OS, assume Unix Socket support (Unix-like fallback) - logger.warning( - f"[PROCESS] Unknown OS type {os_type}, assuming Unix Socket support" - ) - supports = True - - duration_ms = (time.time() - start_time) * 1000 - logger.debug( - f"[EXIT] _check_unix_socket_support return={supports} time_ms={duration_ms:.2f}" - ) - - return supports - - -def detect_platform() -> PlatformInfo: - """Detect platform information - - Pure function with no side effects (except logging). - Detects OS type, Python version, and Unix Socket support. - - Returns: - PlatformInfo: Platform information dataclass - - Example: - >>> info = detect_platform() - >>> print(f"OS: {info.os_type}, Python: {info.python_version}") - OS: windows, Python: (3, 10, 0) - """ - start_time = time.time() - logger.info("[ENTRY] detect_platform inputs={}") - - # Step 1: Detect OS type - os_type = _detect_os_type() - logger.info(f"[PROCESS] Detected OS type: {os_type}") - - # Step 2: Detect Python version - python_version = _detect_python_version() - logger.info(f"[PROCESS] Detected Python version: {python_version}") - - # Step 3: Check Unix Socket support - supports_unix_socket = _check_unix_socket_support(os_type, python_version) - logger.info(f"[PROCESS] Unix Socket support: {supports_unix_socket}") - - # Step 4: Create PlatformInfo - platform_info = PlatformInfo( - os_type=os_type, - python_version=python_version, - supports_unix_socket=supports_unix_socket, - ) - - duration_ms = (time.time() - start_time) * 1000 - logger.info( - f"[EXIT] detect_platform return={platform_info} time_ms={duration_ms:.2f}" - ) - - return platform_info diff --git a/astrbot/core/platform/sources/cli/session/__init__.py b/astrbot/core/platform/sources/cli/session/__init__.py deleted file mode 100644 index 44056af123..0000000000 --- a/astrbot/core/platform/sources/cli/session/__init__.py +++ /dev/null @@ -1,5 +0,0 @@ -"""CLI会话管理模块""" - -from .session_manager import SessionManager - -__all__ = ["SessionManager"] diff --git a/astrbot/core/platform/sources/cli/session/session_manager.py b/astrbot/core/platform/sources/cli/session/session_manager.py deleted file mode 100644 index d5b00e5a0d..0000000000 --- a/astrbot/core/platform/sources/cli/session/session_manager.py +++ /dev/null @@ -1,123 +0,0 @@ -"""会话管理器 - -负责会话的创建、跟踪和过期清理。 -""" - -import asyncio -import time - -from astrbot import logger - - -class SessionManager: - """会话管理器 - - I/O契约: - Input: session_id (str), ttl (int) - Output: None (管理会话生命周期) - """ - - CLEANUP_INTERVAL = 10 # 清理检查间隔（秒） - - def __init__(self, ttl: int = 30, enabled: bool = False): - """初始化会话管理器 - - Args: - ttl: 会话过期时间（秒） - enabled: 是否启用会话隔离 - """ - self.ttl = ttl - self.enabled = enabled - self._timestamps: dict[str, float] = {} - self._cleanup_task: asyncio.Task | None = None - self._running = False - - def register(self, session_id: str) -> None: - """注册新会话 - - Args: - session_id: 会话ID - """ - if not self.enabled: - return - - if session_id not in self._timestamps: - self._timestamps[session_id] = time.time() - logger.debug("Created isolated session: %s, TTL=%ds", session_id, self.ttl) - - def touch(self, session_id: str) -> None: - """更新会话时间戳 - - Args: - session_id: 会话ID - """ - if self.enabled and session_id in self._timestamps: - self._timestamps[session_id] = time.time() - - def is_expired(self, session_id: str) -> bool: - """检查会话是否过期 - - Args: - session_id: 会话ID - - Returns: - 是否过期 - """ - if not self.enabled: - return False - - timestamp = self._timestamps.get(session_id) - if timestamp is None: - return True - - return time.time() - timestamp > self.ttl - - def start_cleanup_task(self) -> None: - """启动清理任务""" - if not self.enabled: - return - - self._running = True - self._cleanup_task = asyncio.create_task(self._cleanup_loop()) - logger.info("Session cleanup task started, TTL=%ds", self.ttl) - - async def stop_cleanup_task(self) -> None: - """停止清理任务""" - self._running = False - - if self._cleanup_task and not self._cleanup_task.done(): - self._cleanup_task.cancel() - try: - await self._cleanup_task - except asyncio.CancelledError: - logger.debug("Cleanup task cancelled") - - async def _cleanup_loop(self) -> None: - """清理循环""" - while self._running: - try: - await asyncio.sleep(self.CLEANUP_INTERVAL) - - if not self.enabled: - continue - - current_time = time.time() - expired_sessions = [ - sid - for sid, ts in list(self._timestamps.items()) - if current_time - ts > self.ttl - ] - - for session_id in expired_sessions: - logger.info("Cleaning expired session: %s", session_id) - self._timestamps.pop(session_id, None) - - if expired_sessions: - logger.info("Cleaned %d expired sessions", len(expired_sessions)) - - except asyncio.CancelledError: - break - except Exception as e: - logger.error("Session cleanup error: %s", e) - - logger.info("Session cleanup task stopped") diff --git a/astrbot/core/platform/sources/cli/socket_abstract.py b/astrbot/core/platform/sources/cli/socket_abstract.py deleted file mode 100644 index 2ec28f20aa..0000000000 --- a/astrbot/core/platform/sources/cli/socket_abstract.py +++ /dev/null @@ -1,120 +0,0 @@ -""" -Abstract Socket Server Interface - -This module defines the abstract base class for socket server implementations. -It provides a unified interface for both Unix Socket and TCP Socket servers, -enabling platform-independent socket communication. - -Design Pattern: Abstract Factory Pattern -I/O Contract: Defines abstract methods that must be implemented by concrete classes -""" - -from abc import ABC, abstractmethod -from typing import Any - - -class AbstractSocketServer(ABC): - """Socket服务器抽象基类 - - 定义统一的Socket服务器接口，供UnixSocketServer和TCPSocketServer实现。 - 所有子类必须实现全部抽象方法。 - - Design Principles: - - Single Responsibility: 仅定义接口契约 - - Open/Closed: 对扩展开放，对修改封闭 - - Liskov Substitution: 子类可替换父类 - - Usage: - class MySocketServer(AbstractSocketServer): - async def start(self) -> None: - # Implementation - pass - - async def stop(self) -> None: - # Implementation - pass - - async def accept_connection(self) -> tuple[Any, Any]: - # Implementation - return (client_socket, client_address) - - def get_connection_info(self) -> dict: - # Implementation - return {"type": "unix", "path": "/tmp/socket"} - """ - - @abstractmethod - async def start(self) -> None: - """启动服务器 - - 启动Socket服务器并开始监听连接。此方法应该是非阻塞的， - 使用asyncio事件循环处理连接。 - - Input: None - Output: None (副作用：启动服务器，开始监听) - - Raises: - OSError: 如果端口已被占用或权限不足 - RuntimeError: 如果服务器已经在运行 - - Example: - server = MySocketServer() - await server.start() - """ - pass - - @abstractmethod - async def stop(self) -> None: - """停止服务器 - - 停止Socket服务器并清理所有资源（关闭socket、删除文件等）。 - 此方法应该优雅地关闭所有活动连接。 - - Input: None - Output: None (副作用：停止服务器，清理资源) - - Example: - await server.stop() - """ - pass - - @abstractmethod - async def accept_connection(self) -> tuple[Any, Any]: - """接受客户端连接 - - 等待并接受一个客户端连接。此方法应该是非阻塞的， - 使用asyncio事件循环等待连接。 - - Input: None - Output: (client_socket, client_address) - - client_socket: 客户端socket对象 - - client_address: 客户端地址（Unix Socket为空字符串，TCP为(host, port)） - - Raises: - OSError: 如果socket已关闭或发生网络错误 - - Example: - client, addr = await server.accept_connection() - """ - pass - - @abstractmethod - def get_connection_info(self) -> dict: - """获取连接信息 - - 返回客户端连接到此服务器所需的信息。 - 不同类型的socket返回不同的字段。 - - Input: None - Output: dict - 连接信息字典 - Unix Socket: {"type": "unix", "path": "/path/to/socket"} - TCP Socket: {"type": "tcp", "host": "127.0.0.1", "port": 12345} - - Example: - info = server.get_connection_info() - if info["type"] == "unix": - print(f"Connect to: {info['path']}") - elif info["type"] == "tcp": - print(f"Connect to: {info['host']}:{info['port']}") - """ - pass diff --git a/astrbot/core/platform/sources/cli/socket_factory.py b/astrbot/core/platform/sources/cli/socket_factory.py deleted file mode 100644 index 810ff12622..0000000000 --- a/astrbot/core/platform/sources/cli/socket_factory.py +++ /dev/null @@ -1,218 +0,0 @@ -""" -Socket Factory Module - -Creates appropriate socket server instances based on platform information -and configuration. Follows the Factory Pattern to encapsulate creation logic. - -Architecture: - Input: PlatformInfo + config dict + auth_token - Output: AbstractSocketServer instance (UnixSocketServer or TCPSocketServer) - -Data Flow: - [Platform Info] + [Config] + [Auth Token] - | - v - [Decision Logic] - | - +----+----+ - | | - v v - Unix TCP - Socket Socket - Server Server -""" - -import os -import time -from typing import Literal - -from astrbot import logger -from astrbot.core.utils.astrbot_path import get_astrbot_temp_path - -from .platform_detector import PlatformInfo -from .socket_abstract import AbstractSocketServer -from .tcp_socket_server import TCPSocketServer -from .unix_socket_server import UnixSocketServer - - -def _determine_socket_type( - platform_info: PlatformInfo, config: dict -) -> Literal["unix", "tcp"]: - """Determine which socket type to use - - Decision Logic: - 1. Check explicit user specification - 2. Auto-detect based on platform - 3. Fallback to auto-detection for invalid values - - Args: - platform_info: Platform detection result - config: Configuration dictionary - - Returns: - Socket type: "unix" or "tcp" - """ - start_time = time.time() - logger.debug( - f"[ENTRY] _determine_socket_type inputs={{platform_info={platform_info}, config={config}}}" - ) - - socket_type_config = config.get("socket_type", "auto") - logger.debug(f"[PROCESS] socket_type from config: {socket_type_config}") - - # Step 1: Handle explicit specification - if socket_type_config == "tcp": - logger.info("[PROCESS] Explicitly specified socket_type=tcp") - result = "tcp" - elif socket_type_config == "unix": - logger.info("[PROCESS] Explicitly specified socket_type=unix") - result = "unix" - elif socket_type_config == "auto": - # Step 2: Auto-detection - logger.debug("[PROCESS] Auto-detection mode") - if ( - platform_info.os_type == "windows" - and not platform_info.supports_unix_socket - ): - logger.info( - "[PROCESS] Auto-detected: Windows without Unix Socket support, using TCP" - ) - result = "tcp" - else: - logger.info( - f"[PROCESS] Auto-detected: {platform_info.os_type} with Unix Socket support, using Unix" - ) - result = "unix" - else: - # Step 3: Invalid value, fallback to auto-detection - logger.warning( - f"[PROCESS] Invalid socket_type '{socket_type_config}', falling back to auto-detection" - ) - if ( - platform_info.os_type == "windows" - and not platform_info.supports_unix_socket - ): - result = "tcp" - else: - result = "unix" - - duration_ms = (time.time() - start_time) * 1000 - logger.debug( - f"[EXIT] _determine_socket_type return={result} time_ms={duration_ms:.2f}" - ) - - return result - - -def _create_unix_socket_server( - config: dict, auth_token: str | None -) -> AbstractSocketServer: - """Create Unix Socket server instance - - Args: - config: Configuration dictionary - auth_token: Authentication token - - Returns: - UnixSocketServer instance - """ - start_time = time.time() - logger.debug( - f"[ENTRY] _create_unix_socket_server inputs={{config={config}, auth_token={'***' if auth_token else None}}}" - ) - - # Get socket path from config or use default (handle None values) - socket_path = config.get("socket_path") or os.path.join( - get_astrbot_temp_path(), "astrbot.sock" - ) - logger.debug(f"[PROCESS] Using Unix Socket path: {socket_path}") - - # Create Unix Socket server - server = UnixSocketServer(socket_path=socket_path, auth_token=auth_token) - - duration_ms = (time.time() - start_time) * 1000 - logger.debug( - f"[EXIT] _create_unix_socket_server return=UnixSocketServer time_ms={duration_ms:.2f}" - ) - - return server - - -def _create_tcp_socket_server( - config: dict, auth_token: str | None -) -> AbstractSocketServer: - """Create TCP Socket server instance - - Args: - config: Configuration dictionary - auth_token: Authentication token - - Returns: - TCPSocketServer instance - """ - start_time = time.time() - logger.debug( - f"[ENTRY] _create_tcp_socket_server inputs={{config={config}, auth_token={'***' if auth_token else None}}}" - ) - - # Get TCP configuration from config or use defaults - tcp_host = config.get("tcp_host", "127.0.0.1") - tcp_port = config.get("tcp_port", 0) - logger.debug(f"[PROCESS] Using TCP host: {tcp_host}, port: {tcp_port}") - - # Create TCP Socket server - server = TCPSocketServer(host=tcp_host, port=tcp_port, auth_token=auth_token) - - duration_ms = (time.time() - start_time) * 1000 - logger.debug( - f"[EXIT] _create_tcp_socket_server return=TCPSocketServer time_ms={duration_ms:.2f}" - ) - - return server - - -def create_socket_server( - platform_info: PlatformInfo, config: dict, auth_token: str | None -) -> AbstractSocketServer: - """Create socket server based on platform and configuration - - Decision Logic: - 1. User explicitly specifies socket_type ("unix" or "tcp") - 2. Auto-detection mode: Windows without Unix Socket support uses TCP - 3. Fallback strategy: Invalid config falls back to auto-detection - - Args: - platform_info: Platform detection result - config: Configuration dictionary containing socket_type, paths, etc. - auth_token: Authentication token (optional) - - Returns: - AbstractSocketServer instance (UnixSocketServer or TCPSocketServer) - - Example: - >>> platform_info = detect_platform() - >>> config = {"socket_type": "auto"} - >>> server = create_socket_server(platform_info, config, "token123") - """ - start_time = time.time() - logger.info( - f"[ENTRY] create_socket_server inputs={{platform_info={platform_info}, " - f"socket_type={config.get('socket_type', 'auto')}, auth_token={'***' if auth_token else None}}}" - ) - - # Step 1: Determine socket type - socket_type = _determine_socket_type(platform_info, config) - logger.info(f"[PROCESS] Selected socket type: {socket_type}") - - # Step 2: Create appropriate server - if socket_type == "tcp": - server = _create_tcp_socket_server(config, auth_token) - else: # socket_type == "unix" - server = _create_unix_socket_server(config, auth_token) - - duration_ms = (time.time() - start_time) * 1000 - logger.info( - f"[EXIT] create_socket_server return={server.__class__.__name__} time_ms={duration_ms:.2f}" - ) - - return server diff --git a/astrbot/core/platform/sources/cli/handlers/socket_handler.py b/astrbot/core/platform/sources/cli/socket_handler.py similarity index 62% rename from astrbot/core/platform/sources/cli/handlers/socket_handler.py rename to astrbot/core/platform/sources/cli/socket_handler.py index 4d1ee7507d..61c2e51c31 100644 --- a/astrbot/core/platform/sources/cli/handlers/socket_handler.py +++ b/astrbot/core/platform/sources/cli/socket_handler.py @@ -1,54 +1,129 @@ -"""Socket客户端处理器 +"""Socket处理器模块 -负责处理单个Socket客户端连接。 +处理Socket客户端连接和Socket模式的生命周期管理。 """ import asyncio import json import os import re +import tempfile import uuid from collections.abc import Callable -from typing import TYPE_CHECKING +from typing import TYPE_CHECKING, Any from astrbot import logger from astrbot.core.message.message_event_result import MessageChain -from ..interfaces import IHandler, IMessageConverter, ISessionManager, ITokenValidator -from ..message.response_builder import ResponseBuilder - if TYPE_CHECKING: from astrbot.core.platform.platform_metadata import PlatformMetadata - from ..cli_event import CLIMessageEvent + from .cli_event import CLIMessageEvent -class SocketClientHandler: - """Socket客户端处理器 +# ------------------------------------------------------------------ +# 连接信息写入 +# ------------------------------------------------------------------ + + +def write_connection_info(connection_info: dict[str, Any], data_dir: str) -> None: + """写入连接信息到文件，供客户端读取""" + if not isinstance(connection_info, dict): + raise ValueError("connection_info must be a dict") + + conn_type = connection_info.get("type") + if conn_type not in ("unix", "tcp"): + raise ValueError(f"Invalid type: {conn_type}, must be 'unix' or 'tcp'") + if conn_type == "unix" and "path" not in connection_info: + raise ValueError("Unix socket requires 'path' field") + if conn_type == "tcp" and ( + "host" not in connection_info or "port" not in connection_info + ): + raise ValueError("TCP socket requires 'host' and 'port' fields") + + target_path = os.path.join(data_dir, ".cli_connection") - 处理单个客户端连接，不实现IHandler（因为它不是独立运行的模式）。 + try: + fd, temp_path = tempfile.mkstemp( + dir=data_dir, prefix=".cli_connection.", suffix=".tmp" + ) + try: + with os.fdopen(fd, "w", encoding="utf-8") as f: + json.dump(connection_info, f, indent=2) + try: + os.chmod(temp_path, 0o600) + except OSError: + pass + os.replace(temp_path, target_path) + except Exception: + if os.path.exists(temp_path): + os.remove(temp_path) + raise + except Exception as e: + logger.error(f"[CLI] Failed to write connection info: {e}") + raise + + +# ------------------------------------------------------------------ +# 响应构建（从message/response_builder.py内联） +# ------------------------------------------------------------------ + + +def _build_success_response( + message_chain: MessageChain, + request_id: str, + images: list[dict], + extra: dict[str, Any] | None = None, +) -> str: + """构建成功响应JSON""" + result = { + "status": "success", + "response": message_chain.get_plain_text(), + "images": images, + "request_id": request_id, + } + if extra: + result.update(extra) + return json.dumps(result, ensure_ascii=False) + + +def _build_error_response( + error_msg: str, + request_id: str | None = None, + error_code: str | None = None, +) -> str: + """构建错误响应JSON""" + result: dict[str, Any] = {"status": "error", "error": error_msg} + if request_id: + result["request_id"] = request_id + if error_code: + result["error_code"] = error_code + return json.dumps(result, ensure_ascii=False) + + +# ------------------------------------------------------------------ +# Socket客户端处理器 +# ------------------------------------------------------------------ - I/O契约: - Input: socket连接 - Output: None (发送JSON响应到客户端) - """ + +class SocketClientHandler: + """处理单个Socket客户端连接""" RECV_BUFFER_SIZE = 4096 - MAX_REQUEST_SIZE = 1024 * 1024 # 1MB 最大请求大小 + MAX_REQUEST_SIZE = 1024 * 1024 # 1MB RESPONSE_TIMEOUT = 120.0 def __init__( self, - token_manager: ITokenValidator, - message_converter: IMessageConverter, - session_manager: ISessionManager, + token_manager, + message_converter, + session_manager, platform_meta: "PlatformMetadata", output_queue: asyncio.Queue, event_committer: Callable[["CLIMessageEvent"], None], use_isolated_sessions: bool = False, data_path: str | None = None, ): - """初始化Socket客户端处理器""" self.token_manager = token_manager self.message_converter = message_converter self.session_manager = session_manager @@ -63,18 +138,14 @@ async def handle(self, client_socket) -> None: try: loop = asyncio.get_running_loop() - # 接收请求（带大小限制） data = await self._recv_with_limit(loop, client_socket) if not data: return - # 解析并验证请求 request = self._parse_request(data) if request is None: await self._send_response( - loop, - client_socket, - ResponseBuilder.build_error("Invalid JSON format"), + loop, client_socket, _build_error_response("Invalid JSON format") ) return @@ -82,7 +153,6 @@ async def handle(self, client_socket) -> None: auth_token = request.get("auth_token", "") action = request.get("action", "") - # Token验证（所有请求都需要token） if not self.token_manager.validate(auth_token): error_msg = ( "Unauthorized: missing token" @@ -92,31 +162,28 @@ async def handle(self, client_socket) -> None: await self._send_response( loop, client_socket, - ResponseBuilder.build_error(error_msg, request_id, "AUTH_FAILED"), + _build_error_response(error_msg, request_id, "AUTH_FAILED"), ) return - # 处理请求 if action == "get_logs": - # 获取日志 response = await self._get_logs(request, request_id) else: - # 处理消息 message_text = request.get("message", "") response = await self._process_message(message_text, request_id) await self._send_response(loop, client_socket, response) except Exception as e: - logger.error("Socket handler error: %s", e, exc_info=True) + logger.error(f"[CLI] Socket handler error: {e}", exc_info=True) finally: try: client_socket.close() except Exception as e: - logger.warning("Failed to close socket: %s", e) + logger.warning(f"[CLI] Failed to close socket: {e}") async def _recv_with_limit(self, loop, client_socket) -> bytes: - """接收数据，带大小限制防止DoS攻击""" + """接收数据，带大小限制""" chunks = [] total_size = 0 @@ -127,35 +194,27 @@ async def _recv_with_limit(self, loop, client_socket) -> bytes: total_size += len(chunk) if total_size > self.MAX_REQUEST_SIZE: - logger.warning( - "Request too large: %d bytes, limit: %d", - total_size, - self.MAX_REQUEST_SIZE, - ) + logger.warning(f"[CLI] Request too large: {total_size} bytes") return b"" chunks.append(chunk) - - # 检查是否接收完整（JSON以}结尾） if chunk.rstrip().endswith(b"}"): break return b"".join(chunks) def _parse_request(self, data: bytes) -> dict | None: - """解析JSON请求""" try: return json.loads(data.decode("utf-8")) except json.JSONDecodeError: return None async def _send_response(self, loop, client_socket, response: str) -> None: - """发送响应""" await loop.sock_sendall(client_socket, response.encode("utf-8")) async def _process_message(self, message_text: str, request_id: str) -> str: """处理消息并返回JSON响应""" - from ..cli_event import CLIMessageEvent + from .cli_event import CLIMessageEvent, extract_images response_future = asyncio.Future() @@ -183,28 +242,14 @@ async def _process_message(self, message_text: str, request_id: str) -> str: response_future, timeout=self.RESPONSE_TIMEOUT ) if message_chain is None: - # 管道完成但没有产生任何回复（被白名单/频率限制等拦截） - return ResponseBuilder.build_success( - MessageChain([]), request_id - ) - return ResponseBuilder.build_success(message_chain, request_id) + return _build_success_response(MessageChain([]), request_id, []) + images = extract_images(message_chain) + return _build_success_response(message_chain, request_id, images) except asyncio.TimeoutError: - return ResponseBuilder.build_error("Request timeout", request_id, "TIMEOUT") + return _build_error_response("Request timeout", request_id, "TIMEOUT") async def _get_logs(self, request: dict, request_id: str) -> str: - """获取日志 - - Args: - request: 请求字典，支持参数: - - lines: 返回最近N行日志（默认100） - - level: 过滤日志级别 (DEBUG/INFO/WARNING/ERROR/CRITICAL) - - pattern: 过滤包含指定字符串的日志 - request_id: 请求ID - - Returns: - JSON格式的响应字符串 - """ - # 日志级别映射：完整名称 -> 日志文件中的缩写 + """获取日志""" LEVEL_MAP = { "DEBUG": "DEBUG", "INFO": "INFO", @@ -215,17 +260,12 @@ async def _get_logs(self, request: dict, request_id: str) -> str: } try: - # 获取参数 - lines = min(request.get("lines", 100), 1000) # 最多1000行 + lines = min(request.get("lines", 100), 1000) level_filter = request.get("level", "").upper() - # 映射到日志文件中的缩写 level_filter = LEVEL_MAP.get(level_filter, level_filter) pattern = request.get("pattern", "") - use_regex = request.get("regex", False) # 是否使用正则表达式 - - logger.debug(f"[LogFilter] lines={lines}, level={level_filter}, pattern={repr(pattern)}, regex={use_regex}") + use_regex = request.get("regex", False) - # 日志文件路径 log_path = os.path.join(self.data_path, "logs", "astrbot.log") if not os.path.exists(log_path): # noqa: ASYNC240 @@ -239,54 +279,37 @@ async def _get_logs(self, request: dict, request_id: str) -> str: ensure_ascii=False, ) - # 读取日志文件（从末尾开始） logs = [] try: with open(log_path, encoding="utf-8", errors="ignore") as f: - # 读取所有行 all_lines = f.readlines() - # 从末尾开始筛选 for line in reversed(all_lines): - # 跳过空行 if not line.strip(): continue - - # 级别过滤（匹配 [级别] 格式） - if level_filter: - # 匹配 [级别] 格式，例如 [ERRO], [WARN], [INFO] - if not re.search(rf'\[{level_filter}\]', line): - continue - - # 模式过滤（支持正则表达式） + if level_filter and not re.search(rf"\[{level_filter}\]", line): + continue if pattern: if use_regex: try: if not re.search(pattern, line): continue except re.error: - # 正则表达式错误，回退到子串匹配 if pattern not in line: continue else: if pattern not in line: continue - logs.append(line.rstrip()) - if len(logs) >= lines: break - except OSError as e: - logger.warning("Failed to read log file: %s", e) - return ResponseBuilder.build_error( + logger.warning(f"[CLI] Failed to read log file: {e}") + return _build_error_response( f"Failed to read log file: {e}", request_id ) - # 反转回来（使时间顺序正确） logs.reverse() - - # 构建响应 log_text = "\n".join(logs) return json.dumps( { @@ -299,15 +322,17 @@ async def _get_logs(self, request: dict, request_id: str) -> str: ) except Exception as e: - logger.exception("Error getting logs") - return ResponseBuilder.build_error(f"Error getting logs: {e}", request_id) + logger.exception("[CLI] Error getting logs") + return _build_error_response(f"Error getting logs: {e}", request_id) -class SocketModeHandler(IHandler): - """Socket模式处理器 +# ------------------------------------------------------------------ +# Socket模式处理器 +# ------------------------------------------------------------------ - 管理Socket服务器的生命周期，实现IHandler接口。 - """ + +class SocketModeHandler: + """管理Socket服务器的生命周期""" def __init__( self, @@ -316,14 +341,6 @@ def __init__( connection_info_writer: Callable[[dict, str], None], data_path: str, ): - """初始化Socket模式处理器 - - Args: - server: Socket服务器实例 - client_handler: 客户端处理器 - connection_info_writer: 连接信息写入函数 - data_path: 数据目录路径 - """ self.server = server self.client_handler = client_handler self.connection_info_writer = connection_info_writer @@ -331,30 +348,24 @@ def __init__( self._running = False async def run(self) -> None: - """运行Socket服务器""" self._running = True - try: await self.server.start() - logger.info("Socket server started: %s", type(self.server).__name__) + logger.info(f"[CLI] Socket server started: {type(self.server).__name__}") - # 写入连接信息 connection_info = self.server.get_connection_info() self.connection_info_writer(connection_info, self.data_path) - # 接受连接循环 while self._running: try: client_socket, _ = await self.server.accept_connection() asyncio.create_task(self.client_handler.handle(client_socket)) except Exception as e: if self._running: - logger.error("Socket accept error: %s", e) + logger.error(f"[CLI] Socket accept error: {e}") await asyncio.sleep(0.1) - finally: await self.server.stop() def stop(self) -> None: - """停止Socket服务器""" self._running = False diff --git a/astrbot/core/platform/sources/cli/socket_server.py b/astrbot/core/platform/sources/cli/socket_server.py new file mode 100644 index 0000000000..f532656d3b --- /dev/null +++ b/astrbot/core/platform/sources/cli/socket_server.py @@ -0,0 +1,249 @@ +"""Socket服务器模块 + +提供Unix Socket和TCP Socket服务器实现，以及平台检测和工厂函数。 +""" + +import asyncio +import os +import platform as platform_mod +import socket +import sys +from abc import ABC, abstractmethod +from dataclasses import dataclass +from typing import Any, Literal + +from astrbot import logger +from astrbot.core.utils.astrbot_path import get_astrbot_temp_path + +# ------------------------------------------------------------------ +# 平台检测 +# ------------------------------------------------------------------ + + +@dataclass +class PlatformInfo: + """平台信息""" + + os_type: Literal["windows", "linux", "darwin"] + python_version: tuple[int, int, int] + supports_unix_socket: bool + + +def detect_platform() -> PlatformInfo: + """检测当前平台信息""" + system = platform_mod.system() + if system == "Windows": + os_type = "windows" + elif system == "Linux": + os_type = "linux" + elif system == "Darwin": + os_type = "darwin" + else: + os_type = "linux" + + vi = sys.version_info + python_version = ( + (vi.major, vi.minor, vi.micro) + if hasattr(vi, "major") + else (vi[0], vi[1], vi[2]) + ) + + supports_unix = os_type in ("linux", "darwin") + if os_type == "windows" and python_version >= (3, 9, 0): + try: + if hasattr(socket, "AF_UNIX"): + test_sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM) + test_sock.close() + supports_unix = True + except (OSError, AttributeError): + pass + + info = PlatformInfo( + os_type=os_type, + python_version=python_version, + supports_unix_socket=supports_unix, + ) + logger.info( + f"[CLI] Platform: {info.os_type}, Python {info.python_version}, unix_socket={info.supports_unix_socket}" + ) + return info + + +# ------------------------------------------------------------------ +# Socket服务器抽象基类 +# ------------------------------------------------------------------ + + +class AbstractSocketServer(ABC): + """Socket服务器抽象基类""" + + @abstractmethod + async def start(self) -> None: + pass + + @abstractmethod + async def stop(self) -> None: + pass + + @abstractmethod + async def accept_connection(self) -> tuple[Any, Any]: + pass + + @abstractmethod + def get_connection_info(self) -> dict: + pass + + +# ------------------------------------------------------------------ +# TCP Socket服务器 +# ------------------------------------------------------------------ + + +class TCPSocketServer(AbstractSocketServer): + """TCP Socket服务器，用于Windows或显式指定TCP的场景""" + + def __init__( + self, host: str = "127.0.0.1", port: int = 0, auth_token: str | None = None + ): + self.host = host + self.port = port + self.auth_token = auth_token + self.server_socket: socket.socket | None = None + self.actual_port: int = port + self._is_running = False + + async def start(self) -> None: + if self._is_running: + raise RuntimeError("Server is already running") + + try: + self.server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM) + self.server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) + self.server_socket.bind((self.host, self.port)) + self.actual_port = self.server_socket.getsockname()[1] + self.server_socket.listen(5) + self.server_socket.setblocking(False) + self._is_running = True + logger.info(f"[CLI] TCP server listening on {self.host}:{self.actual_port}") + except Exception: + if self.server_socket: + self.server_socket.close() + self.server_socket = None + raise + + async def stop(self) -> None: + if not self._is_running and self.server_socket is None: + return + if self.server_socket: + self.server_socket.close() + self.server_socket = None + self._is_running = False + logger.info("[CLI] TCP server stopped") + + async def accept_connection(self) -> tuple[Any, Any]: + if not self._is_running or self.server_socket is None: + raise RuntimeError("Server is not running") + loop = asyncio.get_running_loop() + return await loop.sock_accept(self.server_socket) + + def get_connection_info(self) -> dict: + return {"type": "tcp", "host": self.host, "port": self.actual_port} + + +# ------------------------------------------------------------------ +# Unix Socket服务器 +# ------------------------------------------------------------------ + + +class UnixSocketServer(AbstractSocketServer): + """Unix Domain Socket服务器""" + + def __init__(self, socket_path: str, auth_token: str | None = None) -> None: + if not socket_path: + raise ValueError("socket_path cannot be empty") + self.socket_path = socket_path + self.auth_token = auth_token + self._server_socket: socket.socket | None = None + self._running = False + + async def start(self) -> None: + if self._running: + raise RuntimeError("Server is already running") + + if os.path.exists(self.socket_path): + os.remove(self.socket_path) + + self._server_socket = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM) + self._server_socket.bind(self.socket_path) + os.chmod(self.socket_path, 0o600) + self._server_socket.listen(5) + self._server_socket.setblocking(False) + self._running = True + logger.info(f"[CLI] Unix socket server listening on {self.socket_path}") + + async def stop(self) -> None: + self._running = False + if self._server_socket is not None: + try: + self._server_socket.close() + except Exception as e: + logger.error(f"[CLI] Failed to close socket: {e}") + if os.path.exists(self.socket_path): + try: + os.remove(self.socket_path) + except Exception as e: + logger.error(f"[CLI] Failed to remove socket file: {e}") + self._server_socket = None + logger.info("[CLI] Unix socket server stopped") + + async def accept_connection(self) -> tuple[Any, Any]: + if not self._running or self._server_socket is None: + raise RuntimeError("Server is not started") + loop = asyncio.get_running_loop() + return await loop.sock_accept(self._server_socket) + + def get_connection_info(self) -> dict: + return {"type": "unix", "path": self.socket_path} + + +# ------------------------------------------------------------------ +# 工厂函数 +# ------------------------------------------------------------------ + + +def create_socket_server( + platform_info: PlatformInfo, config: dict, auth_token: str | None +) -> AbstractSocketServer: + """根据平台和配置创建Socket服务器""" + socket_type = config.get("socket_type", "auto") + + if socket_type == "tcp": + use_tcp = True + elif socket_type == "unix": + use_tcp = False + elif socket_type == "auto": + use_tcp = ( + platform_info.os_type == "windows" + and not platform_info.supports_unix_socket + ) + else: + logger.warning( + f"[CLI] Invalid socket_type '{socket_type}', falling back to auto" + ) + use_tcp = ( + platform_info.os_type == "windows" + and not platform_info.supports_unix_socket + ) + + if use_tcp: + host = config.get("tcp_host", "127.0.0.1") + port = config.get("tcp_port", 0) + server = TCPSocketServer(host=host, port=port, auth_token=auth_token) + else: + socket_path = config.get("socket_path") or os.path.join( + get_astrbot_temp_path(), "astrbot.sock" + ) + server = UnixSocketServer(socket_path=socket_path, auth_token=auth_token) + + logger.info(f"[CLI] Created {server.__class__.__name__}") + return server diff --git a/astrbot/core/platform/sources/cli/tcp_socket_server.py b/astrbot/core/platform/sources/cli/tcp_socket_server.py deleted file mode 100644 index 1e9cba3007..0000000000 --- a/astrbot/core/platform/sources/cli/tcp_socket_server.py +++ /dev/null @@ -1,247 +0,0 @@ -""" -TCP Socket Server Implementation - -This module provides a TCP Socket server implementation for Windows compatibility. -It implements the AbstractSocketServer interface using TCP sockets (AF_INET). - -Design Pattern: Strategy Pattern (implements AbstractSocketServer) -Security: Localhost-only binding + Token authentication - -I/O Contract: - Input: host (str), port (int), auth_token (str | None) - Output: AbstractSocketServer instance with TCP socket functionality -""" - -import asyncio -import socket -import time -from typing import Any - -from astrbot import logger - -from .socket_abstract import AbstractSocketServer - - -class TCPSocketServer(AbstractSocketServer): - """TCP Socket服务器实现 - - 用于Windows环境的Socket服务器，使用TCP协议（AF_INET）。 - 仅监听localhost（127.0.0.1），通过Token认证保证安全性。 - - Attributes: - host: 监听地址（默认127.0.0.1） - port: 监听端口（0表示随机端口） - auth_token: 认证Token（可选但强烈推荐） - server_socket: TCP socket对象 - actual_port: 实际绑定的端口号 - - Security: - - 仅监听localhost，不暴露到网络 - - 支持Token认证（应用层安全） - - 记录所有连接尝试 - - Example: - server = TCPSocketServer(port=0, auth_token="secret") - await server.start() - client, addr = await server.accept_connection() - await server.stop() - """ - - def __init__( - self, host: str = "127.0.0.1", port: int = 0, auth_token: str | None = None - ): - """初始化TCP Socket服务器 - - Args: - host: 监听地址，默认127.0.0.1（仅本地访问） - port: 监听端口，0表示随机端口 - auth_token: 认证Token，用于验证客户端身份 - - Note: - 强烈建议设置auth_token，因为TCP Socket无文件权限保护 - """ - self.host = host - self.port = port - self.auth_token = auth_token - self.server_socket: socket.socket | None = None - self.actual_port: int = port - self._is_running = False - - async def start(self) -> None: - """启动TCP Socket服务器 - - 创建TCP socket，绑定到指定地址和端口，开始监听连接。 - 使用非阻塞模式，与asyncio事件循环集成。 - - Input: None - Output: None (副作用：启动服务器，开始监听) - - Raises: - RuntimeError: 如果服务器已经在运行 - OSError: 如果端口已被占用或权限不足 - - Logging: - [ENTRY] start inputs={host, port} - [PROCESS] Socket created and bound - [EXIT] start return=None time_ms={duration} - """ - start_time = time.time() - logger.debug( - f"[ENTRY] TCPSocketServer.start inputs={{host={self.host}, port={self.port}}}" - ) - - if self._is_running: - logger.error("[ERROR] TCPSocketServer.start: Server already running") - raise RuntimeError("Server is already running") - - try: - # Create TCP socket - self.server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM) - self.server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) - logger.debug("[PROCESS] TCP socket created") - - # Bind to localhost only (security) - self.server_socket.bind((self.host, self.port)) - self.actual_port = self.server_socket.getsockname()[1] - logger.debug(f"[PROCESS] Socket bound to {self.host}:{self.actual_port}") - - # Start listening - self.server_socket.listen(5) - self.server_socket.setblocking(False) - logger.debug("[PROCESS] Socket listening (non-blocking mode)") - - self._is_running = True - - duration_ms = (time.time() - start_time) * 1000 - logger.info( - f"[EXIT] TCPSocketServer.start return=None time_ms={duration_ms:.2f} " - f"actual_port={self.actual_port}" - ) - - except Exception as e: - logger.error( - f"[ERROR] TCPSocketServer.start failed: {type(e).__name__}: {e}", - exc_info=True, - ) - # Cleanup on failure - if self.server_socket: - self.server_socket.close() - self.server_socket = None - raise - - async def stop(self) -> None: - """停止TCP Socket服务器 - - 关闭socket连接并清理所有资源。 - 此方法是幂等的，可以安全地多次调用。 - - Input: None - Output: None (副作用：停止服务器，清理资源) - - Logging: - [ENTRY] stop inputs={} - [PROCESS] Closing socket - [EXIT] stop return=None time_ms={duration} - """ - start_time = time.time() - logger.debug("[ENTRY] TCPSocketServer.stop inputs={}") - - if not self._is_running and self.server_socket is None: - logger.debug("[PROCESS] Server not running, nothing to stop") - return - - try: - if self.server_socket: - logger.debug("[PROCESS] Closing TCP socket") - self.server_socket.close() - self.server_socket = None - - self._is_running = False - - duration_ms = (time.time() - start_time) * 1000 - logger.info( - f"[EXIT] TCPSocketServer.stop return=None time_ms={duration_ms:.2f}" - ) - - except Exception as e: - logger.error( - f"[ERROR] TCPSocketServer.stop failed: {type(e).__name__}: {e}", - exc_info=True, - ) - # Ensure cleanup even on error - self.server_socket = None - self._is_running = False - raise - - async def accept_connection(self) -> tuple[Any, Any]: - """接受客户端连接 - - 等待并接受一个客户端连接。使用asyncio事件循环实现非阻塞等待。 - - Input: None - Output: (client_socket, client_address) - - client_socket: 客户端socket对象 - - client_address: 客户端地址元组 (host, port) - - Raises: - OSError: 如果socket已关闭或发生网络错误 - RuntimeError: 如果服务器未启动 - - Logging: - [ENTRY] accept_connection inputs={} - [PROCESS] Waiting for connection - [PROCESS] Connection accepted from {address} - [EXIT] accept_connection return=(socket, address) time_ms={duration} - """ - start_time = time.time() - logger.debug("[ENTRY] TCPSocketServer.accept_connection inputs={}") - - if not self._is_running or self.server_socket is None: - logger.error( - "[ERROR] TCPSocketServer.accept_connection: Server not started" - ) - raise RuntimeError("Server is not running") - - try: - logger.debug("[PROCESS] Waiting for client connection") - - # Use asyncio event loop for non-blocking accept - loop = asyncio.get_running_loop() - client_socket, client_address = await loop.sock_accept(self.server_socket) - - logger.debug(f"[PROCESS] Connection accepted from {client_address}") - - duration_ms = (time.time() - start_time) * 1000 - logger.info( - f"[EXIT] TCPSocketServer.accept_connection " - f"return=(socket, {client_address}) time_ms={duration_ms:.2f}" - ) - - return client_socket, client_address - - except Exception as e: - logger.error( - f"[ERROR] TCPSocketServer.accept_connection failed: {type(e).__name__}: {e}", - exc_info=True, - ) - raise - - def get_connection_info(self) -> dict: - """获取连接信息 - - 返回客户端连接到此服务器所需的信息。 - 包含socket类型、主机地址和端口号。 - - Input: None - Output: dict - 连接信息字典 - { - "type": "tcp", - "host": "127.0.0.1", - "port": 12345 - } - - Example: - info = server.get_connection_info() - print(f"Connect to: {info['host']}:{info['port']}") - """ - return {"type": "tcp", "host": self.host, "port": self.actual_port} diff --git a/astrbot/core/platform/sources/cli/handlers/tty_handler.py b/astrbot/core/platform/sources/cli/tty_handler.py similarity index 79% rename from astrbot/core/platform/sources/cli/handlers/tty_handler.py rename to astrbot/core/platform/sources/cli/tty_handler.py index 6e15e1d8b3..e3a87e42ad 100644 --- a/astrbot/core/platform/sources/cli/handlers/tty_handler.py +++ b/astrbot/core/platform/sources/cli/tty_handler.py @@ -1,7 +1,4 @@ -"""TTY交互模式处理器 - -负责处理TTY交互模式的输入输出。 -""" +"""TTY交互模式处理器""" import asyncio from collections.abc import Callable @@ -10,23 +7,14 @@ from astrbot import logger from astrbot.core.message.message_event_result import MessageChain -from ..interfaces import IHandler, IMessageConverter - if TYPE_CHECKING: from astrbot.core.platform.platform_metadata import PlatformMetadata - from ..cli_event import CLIMessageEvent + from .cli_event import CLIMessageEvent -class TTYHandler(IHandler): - """TTY交互模式处理器 - - 实现IHandler接口，提供命令行交互功能。 - - I/O契约: - Input: 用户键盘输入 - Output: None (打印到stdout) - """ +class TTYHandler: + """TTY交互模式处理器""" EXIT_COMMANDS = frozenset({"exit", "quit"}) BANNER = """ @@ -40,12 +28,11 @@ class TTYHandler(IHandler): def __init__( self, - message_converter: IMessageConverter, + message_converter, platform_meta: "PlatformMetadata", output_queue: asyncio.Queue, event_committer: Callable[["CLIMessageEvent"], None], ): - """初始化TTY处理器""" self.message_converter = message_converter self.platform_meta = platform_meta self.output_queue = output_queue @@ -53,7 +40,6 @@ def __init__( self._running = False async def run(self) -> None: - """运行TTY交互模式""" self._running = True print(self.BANNER) @@ -62,7 +48,7 @@ async def run(self) -> None: try: await self._input_loop() except KeyboardInterrupt: - logger.info("Received KeyboardInterrupt") + logger.info("[CLI] Received KeyboardInterrupt") finally: self._running = False output_task.cancel() @@ -72,31 +58,23 @@ async def run(self) -> None: pass def stop(self) -> None: - """停止TTY模式""" self._running = False async def _input_loop(self) -> None: - """输入循环""" loop = asyncio.get_running_loop() - while self._running: user_input = await loop.run_in_executor(None, input, "You: ") user_input = user_input.strip() - if not user_input: continue - if user_input.lower() in self.EXIT_COMMANDS: break - await self._handle_input(user_input) async def _handle_input(self, text: str) -> None: - """处理用户输入""" - from ..cli_event import CLIMessageEvent + from .cli_event import CLIMessageEvent message = self.message_converter.convert(text) - message_event = CLIMessageEvent( message_str=message.message_str, message_obj=message, @@ -104,11 +82,9 @@ async def _handle_input(self, text: str) -> None: session_id=message.session_id, output_queue=self.output_queue, ) - self.event_committer(message_event) async def _output_loop(self) -> None: - """输出循环""" while self._running: try: message_chain = await asyncio.wait_for( @@ -121,5 +97,4 @@ async def _output_loop(self) -> None: break def _print_response(self, message_chain: MessageChain) -> None: - """打印响应""" print(f"\nBot: {message_chain.get_plain_text()}\n") diff --git a/astrbot/core/platform/sources/cli/unix_socket_server.py b/astrbot/core/platform/sources/cli/unix_socket_server.py deleted file mode 100644 index 6d8641d838..0000000000 --- a/astrbot/core/platform/sources/cli/unix_socket_server.py +++ /dev/null @@ -1,213 +0,0 @@ -""" -Unix Socket Server Implementation - -This module provides Unix Socket server implementation for Linux/Unix environments. -It handles socket creation, permission management, and connection acceptance. - -Design Pattern: Concrete implementation of AbstractSocketServer -I/O Contract: Implements all abstract methods defined in AbstractSocketServer -""" - -import asyncio -import os -import socket -from typing import Any - -from astrbot import logger - -from .socket_abstract import AbstractSocketServer - - -class UnixSocketServer(AbstractSocketServer): - """Unix Socket服务器实现 - - 职责： - - 创建和管理Unix Domain Socket - - 设置严格的文件权限(0o600) - - 接受客户端连接 - - 清理资源 - - I/O契约： - Input: socket_path (str), auth_token (str | None) - Output: AbstractSocketServer实例 - - 设计原则： - - Single Responsibility: 仅处理Unix Socket相关逻辑 - - Explicit I/O: 所有输入通过构造函数，输出通过方法返回 - - Stateless where possible: 最小化内部状态 - - Usage: - server = UnixSocketServer(socket_path="/tmp/app.sock") - await server.start() - client, addr = await server.accept_connection() - await server.stop() - """ - - def __init__(self, socket_path: str, auth_token: str | None = None) -> None: - """初始化Unix Socket服务器 - - Args: - socket_path: Socket文件路径 - auth_token: 认证Token（可选，用于上层验证） - - Raises: - ValueError: 如果socket_path为空 - """ - logger.info( - "[ENTRY] UnixSocketServer.__init__ inputs={socket_path=%s, has_token=%s}", - socket_path, - auth_token is not None, - ) - - if not socket_path: - raise ValueError("socket_path cannot be empty") - - self.socket_path = socket_path - self.auth_token = auth_token - self._server_socket: socket.socket | None = None - self._running = False - - logger.info("[EXIT] UnixSocketServer.__init__ return=None") - - async def start(self) -> None: - """启动Unix Socket服务器 - - 创建socket文件，设置权限，开始监听连接。 - - I/O契约： - Input: None - Output: None (副作用：创建socket文件，开始监听) - - Raises: - RuntimeError: 如果服务器已经在运行 - OSError: 如果无法创建socket或设置权限 - - Implementation: - 1. 检查是否已启动 - 2. 删除旧的socket文件（如果存在） - 3. 创建AF_UNIX socket - 4. 绑定到socket_path - 5. 设置0o600权限 - 6. 开始监听（backlog=5） - 7. 设置非阻塞模式 - """ - logger.info("[ENTRY] UnixSocketServer.start inputs=None") - - if self._running: - raise RuntimeError("Server is already running") - - # 删除旧的socket文件 - if os.path.exists(self.socket_path): - os.remove(self.socket_path) - logger.info("[PROCESS] Removed old socket file: %s", self.socket_path) - - # 创建Unix socket - self._server_socket = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM) - self._server_socket.bind(self.socket_path) - logger.info("[PROCESS] Socket bound to: %s", self.socket_path) - - # 设置严格权限(仅所有者可访问) - os.chmod(self.socket_path, 0o600) - logger.info("[SECURITY] Socket permissions set to 600: %s", self.socket_path) - - # 开始监听 - self._server_socket.listen(5) - self._server_socket.setblocking(False) - self._running = True - - logger.info("[EXIT] UnixSocketServer.start return=None") - - async def stop(self) -> None: - """停止Unix Socket服务器 - - 关闭socket连接，删除socket文件，清理资源。 - - I/O契约： - Input: None - Output: None (副作用：关闭socket，删除文件) - - Implementation: - 1. 标记为非运行状态 - 2. 关闭server socket - 3. 删除socket文件 - 4. 清理内部状态 - """ - logger.info("[ENTRY] UnixSocketServer.stop inputs=None") - - self._running = False - - # 关闭socket - if self._server_socket is not None: - try: - self._server_socket.close() - logger.info("[PROCESS] Server socket closed") - except Exception as e: - logger.error("[ERROR] Failed to close socket: %s", e) - - # 删除socket文件 - if os.path.exists(self.socket_path): - try: - os.remove(self.socket_path) - logger.info("[PROCESS] Socket file removed: %s", self.socket_path) - except Exception as e: - logger.error("[ERROR] Failed to remove socket file: %s", e) - - self._server_socket = None - logger.info("[EXIT] UnixSocketServer.stop return=None") - - async def accept_connection(self) -> tuple[Any, Any]: - """接受客户端连接 - - 等待并接受一个客户端连接。使用asyncio事件循环实现非阻塞等待。 - - I/O契约： - Input: None - Output: (client_socket, client_address) - - client_socket: 客户端socket对象 - - client_address: 客户端地址（Unix Socket为空字符串） - - Raises: - RuntimeError: 如果服务器未启动 - OSError: 如果socket已关闭或发生网络错误 - - Implementation: - 1. 检查服务器是否已启动 - 2. 使用asyncio.loop.sock_accept()非阻塞等待连接 - 3. 返回客户端socket和地址 - """ - logger.debug("[ENTRY] UnixSocketServer.accept_connection inputs=None") - - if not self._running or self._server_socket is None: - raise RuntimeError("Server is not started") - - # 使用asyncio事件循环接受连接（非阻塞） - loop = asyncio.get_running_loop() - client_socket, client_addr = await loop.sock_accept(self._server_socket) - - logger.debug( - "[EXIT] UnixSocketServer.accept_connection return=(socket, %s)", client_addr - ) - return client_socket, client_addr - - def get_connection_info(self) -> dict: - """获取连接信息 - - 返回客户端连接到此服务器所需的信息。 - - I/O契约： - Input: None - Output: dict - 连接信息字典 - { - "type": "unix", - "path": "/path/to/socket" - } - - Implementation: - 返回包含socket类型和路径的字典 - """ - logger.debug("[ENTRY] UnixSocketServer.get_connection_info inputs=None") - - info = {"type": "unix", "path": self.socket_path} - - logger.debug("[EXIT] UnixSocketServer.get_connection_info return=%s", info) - return info diff --git a/astrbot/core/platform/sources/cli/utils/__init__.py b/astrbot/core/platform/sources/cli/utils/__init__.py deleted file mode 100644 index f364a5fcc0..0000000000 --- a/astrbot/core/platform/sources/cli/utils/__init__.py +++ /dev/null @@ -1,56 +0,0 @@ -"""CLI工具模块 - AOP装饰器集合 - -提供横切关注点的装饰器： -- 异常处理: handle_exceptions, CLIError, AuthenticationError, ValidationError, TimeoutError -- 重试机制: retry -- 超时控制: timeout -- 日志记录: log_entry_exit, log_performance, log_request -- 权限校验: require_auth, require_whitelist -- 组合装饰器: with_logging_and_error_handling -""" - -from .decorators import ( - AuthenticationError, - # 异常类 - CLIError, - TimeoutError, - ValidationError, - # 异常处理 - handle_exceptions, - # 日志 - log_entry_exit, - log_performance, - log_request, - # 权限 - require_auth, - require_whitelist, - # 重试 - retry, - # 超时 - timeout, - # 组合 - with_logging_and_error_handling, -) - -__all__ = [ - # 异常类 - "CLIError", - "AuthenticationError", - "ValidationError", - "TimeoutError", - # 异常处理 - "handle_exceptions", - # 重试 - "retry", - # 超时 - "timeout", - # 日志 - "log_entry_exit", - "log_performance", - "log_request", - # 权限 - "require_auth", - "require_whitelist", - # 组合 - "with_logging_and_error_handling", -] diff --git a/astrbot/core/platform/sources/cli/utils/decorators.py b/astrbot/core/platform/sources/cli/utils/decorators.py deleted file mode 100644 index ed2448ac58..0000000000 --- a/astrbot/core/platform/sources/cli/utils/decorators.py +++ /dev/null @@ -1,496 +0,0 @@ -"""AOP装饰器集合 - -将横切关注点（日志、异常处理、权限校验、重试）从业务代码中抽离。 -遵循单一职责原则，每个装饰器只处理一个关注点。 -""" - -import asyncio -import functools -import time -from collections.abc import Callable -from typing import TypeVar - -from astrbot import logger - -F = TypeVar("F", bound=Callable) - - -# ============================================================ -# 异常处理装饰器 -# ============================================================ - - -class CLIError(Exception): - """CLI模块基础异常""" - - def __init__(self, message: str, error_code: str = "CLI_ERROR"): - super().__init__(message) - self.error_code = error_code - - -class AuthenticationError(CLIError): - """认证失败异常""" - - def __init__(self, message: str = "Authentication failed"): - super().__init__(message, "AUTH_FAILED") - - -class ValidationError(CLIError): - """验证失败异常""" - - def __init__(self, message: str = "Validation failed"): - super().__init__(message, "VALIDATION_ERROR") - - -class TimeoutError(CLIError): - """超时异常""" - - def __init__(self, message: str = "Operation timed out"): - super().__init__(message, "TIMEOUT") - - -def handle_exceptions( - *exception_types: type[Exception], - default_return=None, - reraise: bool = False, - log_level: str = "error", -): - """统一异常处理装饰器 - - Args: - exception_types: 要捕获的异常类型，默认捕获所有Exception - default_return: 异常时的默认返回值 - reraise: 是否重新抛出异常 - log_level: 日志级别 (debug/info/warning/error) - """ - if not exception_types: - exception_types = (Exception,) - - def decorator(func: F) -> F: - @functools.wraps(func) - async def async_wrapper(*args, **kwargs): - try: - return await func(*args, **kwargs) - except exception_types as e: - _log_exception(func.__qualname__, e, log_level) - if reraise: - raise - return default_return - - @functools.wraps(func) - def sync_wrapper(*args, **kwargs): - try: - return func(*args, **kwargs) - except exception_types as e: - _log_exception(func.__qualname__, e, log_level) - if reraise: - raise - return default_return - - if asyncio.iscoroutinefunction(func): - return async_wrapper - return sync_wrapper - - return decorator - - -def _log_exception(func_name: str, exc: Exception, level: str) -> None: - """记录异常日志""" - log_func = getattr(logger, level, logger.error) - error_code = getattr(exc, "error_code", "UNKNOWN") - log_func("[EXCEPTION] %s: %s (code=%s)", func_name, exc, error_code) - - -# ============================================================ -# 重试装饰器 -# ============================================================ - - -def retry( - max_attempts: int = 3, - delay: float = 1.0, - backoff: float = 2.0, - exceptions: tuple = (Exception,), -): - """重试装饰器 - - Args: - max_attempts: 最大重试次数 - delay: 初始延迟（秒） - backoff: 延迟倍增因子 - exceptions: 触发重试的异常类型 - """ - - def decorator(func: F) -> F: - @functools.wraps(func) - async def async_wrapper(*args, **kwargs): - current_delay = delay - last_exception = None - - for attempt in range(max_attempts): - try: - return await func(*args, **kwargs) - except exceptions as e: - last_exception = e - if attempt < max_attempts - 1: - logger.warning( - "[RETRY] %s attempt %d/%d failed: %s, retrying in %.1fs", - func.__qualname__, - attempt + 1, - max_attempts, - e, - current_delay, - ) - await asyncio.sleep(current_delay) - current_delay *= backoff - else: - logger.error( - "[RETRY] %s all %d attempts failed", - func.__qualname__, - max_attempts, - ) - - raise last_exception - - @functools.wraps(func) - def sync_wrapper(*args, **kwargs): - current_delay = delay - last_exception = None - - for attempt in range(max_attempts): - try: - return func(*args, **kwargs) - except exceptions as e: - last_exception = e - if attempt < max_attempts - 1: - logger.warning( - "[RETRY] %s attempt %d/%d failed: %s, retrying in %.1fs", - func.__qualname__, - attempt + 1, - max_attempts, - e, - current_delay, - ) - time.sleep(current_delay) - current_delay *= backoff - else: - logger.error( - "[RETRY] %s all %d attempts failed", - func.__qualname__, - max_attempts, - ) - - raise last_exception - - if asyncio.iscoroutinefunction(func): - return async_wrapper - return sync_wrapper - - return decorator - - -# ============================================================ -# 超时装饰器 -# ============================================================ - - -def timeout(seconds: float): - """超时装饰器 - - Args: - seconds: 超时时间（秒） - """ - - def decorator(func: F) -> F: - @functools.wraps(func) - async def async_wrapper(*args, **kwargs): - try: - return await asyncio.wait_for( - func(*args, **kwargs), - timeout=seconds, - ) - except asyncio.TimeoutError: - logger.error( - "[TIMEOUT] %s exceeded %.1fs", - func.__qualname__, - seconds, - ) - raise TimeoutError(f"{func.__qualname__} timed out after {seconds}s") - - if not asyncio.iscoroutinefunction(func): - raise TypeError("timeout decorator only supports async functions") - - return async_wrapper - - return decorator - - -# ============================================================ -# 日志装饰器 -# ============================================================ - - -def log_entry_exit(func: F) -> F: - """记录函数入口和出口的装饰器 - - 用于异步函数，记录调用开始和结束。 - """ - - @functools.wraps(func) - async def async_wrapper(*args, **kwargs): - func_name = func.__qualname__ - logger.debug("[ENTRY] %s", func_name) - try: - result = await func(*args, **kwargs) - logger.debug("[EXIT] %s", func_name) - return result - except Exception as e: - logger.error("[ERROR] %s: %s", func_name, e) - raise - - @functools.wraps(func) - def sync_wrapper(*args, **kwargs): - func_name = func.__qualname__ - logger.debug("[ENTRY] %s", func_name) - try: - result = func(*args, **kwargs) - logger.debug("[EXIT] %s", func_name) - return result - except Exception as e: - logger.error("[ERROR] %s: %s", func_name, e) - raise - - import asyncio - - if asyncio.iscoroutinefunction(func): - return async_wrapper - return sync_wrapper - - -def log_performance(threshold_ms: float = 100.0): - """记录性能的装饰器 - - 当执行时间超过阈值时记录警告。 - - Args: - threshold_ms: 阈值（毫秒） - """ - - def decorator(func: F) -> F: - @functools.wraps(func) - async def async_wrapper(*args, **kwargs): - start = time.perf_counter() - try: - return await func(*args, **kwargs) - finally: - elapsed_ms = (time.perf_counter() - start) * 1000 - if elapsed_ms > threshold_ms: - logger.warning( - "[PERF] %s took %.2fms (threshold: %.2fms)", - func.__qualname__, - elapsed_ms, - threshold_ms, - ) - - @functools.wraps(func) - def sync_wrapper(*args, **kwargs): - start = time.perf_counter() - try: - return func(*args, **kwargs) - finally: - elapsed_ms = (time.perf_counter() - start) * 1000 - if elapsed_ms > threshold_ms: - logger.warning( - "[PERF] %s took %.2fms (threshold: %.2fms)", - func.__qualname__, - elapsed_ms, - threshold_ms, - ) - - import asyncio - - if asyncio.iscoroutinefunction(func): - return async_wrapper - return sync_wrapper - - return decorator - - -def log_request(func: F) -> F: - """记录请求处理的装饰器 - - 专门用于请求处理函数，记录请求ID和处理结果。 - """ - - @functools.wraps(func) - async def wrapper(*args, **kwargs): - request_id = kwargs.get("request_id", "unknown") - func_name = func.__qualname__ - - logger.info("[REQUEST] %s started, request_id=%s", func_name, request_id) - start = time.perf_counter() - - try: - result = await func(*args, **kwargs) - elapsed_ms = (time.perf_counter() - start) * 1000 - logger.info( - "[REQUEST] %s completed, request_id=%s, elapsed=%.2fms", - func_name, - request_id, - elapsed_ms, - ) - return result - except Exception as e: - elapsed_ms = (time.perf_counter() - start) * 1000 - logger.error( - "[REQUEST] %s failed, request_id=%s, elapsed=%.2fms, error=%s", - func_name, - request_id, - elapsed_ms, - e, - ) - raise - - return wrapper - - -# ============================================================ -# 权限校验装饰器 -# ============================================================ - - -def require_auth(token_getter: Callable[[], str | None] = None): - """权限校验装饰器 - - Args: - token_getter: 获取有效token的函数，返回None表示禁用验证 - """ - - def decorator(func: F) -> F: - @functools.wraps(func) - async def async_wrapper(*args, **kwargs): - # 从kwargs获取提供的token - provided_token = kwargs.get("auth_token", "") - - # 获取有效token - valid_token = token_getter() if token_getter else None - - # 如果没有配置token，跳过验证 - if valid_token is None: - return await func(*args, **kwargs) - - # 验证token - if not provided_token: - logger.warning("[AUTH] Missing auth_token") - raise AuthenticationError("Missing authentication token") - - if provided_token != valid_token: - logger.warning( - "[AUTH] Invalid auth_token (length=%d)", len(provided_token) - ) - raise AuthenticationError("Invalid authentication token") - - return await func(*args, **kwargs) - - @functools.wraps(func) - def sync_wrapper(*args, **kwargs): - provided_token = kwargs.get("auth_token", "") - valid_token = token_getter() if token_getter else None - - if valid_token is None: - return func(*args, **kwargs) - - if not provided_token: - logger.warning("[AUTH] Missing auth_token") - raise AuthenticationError("Missing authentication token") - - if provided_token != valid_token: - logger.warning( - "[AUTH] Invalid auth_token (length=%d)", len(provided_token) - ) - raise AuthenticationError("Invalid authentication token") - - return func(*args, **kwargs) - - if asyncio.iscoroutinefunction(func): - return async_wrapper - return sync_wrapper - - return decorator - - -def require_whitelist( - whitelist: list[str] = None, id_getter: Callable[[tuple, dict], str] = None -): - """白名单校验装饰器 - - Args: - whitelist: 允许的ID列表，空列表表示允许所有 - id_getter: 从参数中获取ID的函数 - """ - - def decorator(func: F) -> F: - @functools.wraps(func) - async def async_wrapper(*args, **kwargs): - if whitelist and id_getter: - request_id = id_getter(args, kwargs) - if request_id not in whitelist: - logger.warning("[WHITELIST] Rejected request from: %s", request_id) - raise AuthenticationError(f"ID {request_id} not in whitelist") - return await func(*args, **kwargs) - - @functools.wraps(func) - def sync_wrapper(*args, **kwargs): - if whitelist and id_getter: - request_id = id_getter(args, kwargs) - if request_id not in whitelist: - logger.warning("[WHITELIST] Rejected request from: %s", request_id) - raise AuthenticationError(f"ID {request_id} not in whitelist") - return func(*args, **kwargs) - - if asyncio.iscoroutinefunction(func): - return async_wrapper - return sync_wrapper - - return decorator - - -# ============================================================ -# 组合装饰器 -# ============================================================ - - -def with_logging_and_error_handling( - log_entry: bool = True, - log_perf: bool = False, - perf_threshold_ms: float = 100.0, - handle_errors: bool = True, - default_return=None, -): - """组合装饰器：日志 + 异常处理 - - 简化常见的装饰器组合使用。 - - Args: - log_entry: 是否记录入口/出口 - log_perf: 是否记录性能 - perf_threshold_ms: 性能阈值 - handle_errors: 是否处理异常 - default_return: 异常时的默认返回值 - """ - - def decorator(func: F) -> F: - decorated = func - - if handle_errors: - decorated = handle_exceptions(default_return=default_return)(decorated) - - if log_perf: - decorated = log_performance(perf_threshold_ms)(decorated) - - if log_entry: - decorated = log_entry_exit(decorated) - - return decorated - - return decorator diff --git a/tests/test_cli/test_client_e2e.py b/tests/test_cli/test_client_e2e.py index e9c417d7c4..0edb8c26ad 100644 --- a/tests/test_cli/test_client_e2e.py +++ b/tests/test_cli/test_client_e2e.py @@ -50,6 +50,19 @@ def _server_reachable() -> bool: return False +def _send_with_retry(message: str, retries: int = 3, delay: float = 1.0, **kwargs) -> dict: + """发送消息，失败时自动重试（应对服务端短暂繁忙）""" + last_resp = None + for i in range(retries): + resp = send_message(message, **kwargs) + if resp.get("status") == "success": + return resp + last_resp = resp + if i < retries - 1: + time.sleep(delay) + return last_resp + + # 如果服务端不可达，跳过所有测试 pytestmark = [ pytest.mark.skipif( @@ -432,14 +445,10 @@ class TestLongChainScenarios: def test_scenario_new_user_onboarding(self): """场景：新用户首次使用 - 链路：status → help → sid → plugin ls → model + 链路：help → sid → plugin ls → model """ - # 1. 检查连接状态 - resp = send_message("/help") - assert resp["status"] == "success" - - # 2. 查看帮助 - resp = send_message("/help") + # 1. 查看帮助（带重试，前面测试可能导致服务端短暂繁忙） + resp = _send_with_retry("/help") assert resp["status"] == "success" assert "/help" in resp["response"] diff --git a/tests/test_cli/test_decorators.py b/tests/test_cli/test_decorators.py deleted file mode 100644 index 7b0fae7d26..0000000000 --- a/tests/test_cli/test_decorators.py +++ /dev/null @@ -1,408 +0,0 @@ -"""AOP装饰器单元测试""" - -import asyncio - -import pytest - - -class TestExceptionClasses: - """异常类测试""" - - def test_cli_error(self): - """测试CLI基础异常""" - from astrbot.core.platform.sources.cli.utils.decorators import CLIError - - error = CLIError("Test error", "TEST_CODE") - assert str(error) == "Test error" - assert error.error_code == "TEST_CODE" - - def test_authentication_error(self): - """测试认证异常""" - from astrbot.core.platform.sources.cli.utils.decorators import ( - AuthenticationError, - ) - - error = AuthenticationError() - assert error.error_code == "AUTH_FAILED" - - error2 = AuthenticationError("Custom message") - assert str(error2) == "Custom message" - - def test_validation_error(self): - """测试验证异常""" - from astrbot.core.platform.sources.cli.utils.decorators import ValidationError - - error = ValidationError() - assert error.error_code == "VALIDATION_ERROR" - - def test_timeout_error(self): - """测试超时异常""" - from astrbot.core.platform.sources.cli.utils.decorators import TimeoutError - - error = TimeoutError() - assert error.error_code == "TIMEOUT" - - -class TestHandleExceptions: - """异常处理装饰器测试""" - - def test_sync_no_exception(self): - """测试同步函数无异常""" - from astrbot.core.platform.sources.cli.utils.decorators import handle_exceptions - - @handle_exceptions() - def func(): - return "success" - - assert func() == "success" - - def test_sync_with_exception(self): - """测试同步函数有异常""" - from astrbot.core.platform.sources.cli.utils.decorators import handle_exceptions - - @handle_exceptions(default_return="default") - def func(): - raise ValueError("test error") - - assert func() == "default" - - def test_sync_reraise(self): - """测试同步函数重新抛出异常""" - from astrbot.core.platform.sources.cli.utils.decorators import handle_exceptions - - @handle_exceptions(reraise=True) - def func(): - raise ValueError("test error") - - with pytest.raises(ValueError): - func() - - @pytest.mark.asyncio - async def test_async_no_exception(self): - """测试异步函数无异常""" - from astrbot.core.platform.sources.cli.utils.decorators import handle_exceptions - - @handle_exceptions() - async def func(): - return "success" - - assert await func() == "success" - - @pytest.mark.asyncio - async def test_async_with_exception(self): - """测试异步函数有异常""" - from astrbot.core.platform.sources.cli.utils.decorators import handle_exceptions - - @handle_exceptions(default_return="default") - async def func(): - raise ValueError("test error") - - assert await func() == "default" - - -class TestRetry: - """重试装饰器测试""" - - def test_sync_success_first_try(self): - """测试同步函数首次成功""" - from astrbot.core.platform.sources.cli.utils.decorators import retry - - call_count = 0 - - @retry(max_attempts=3, delay=0.01) - def func(): - nonlocal call_count - call_count += 1 - return "success" - - assert func() == "success" - assert call_count == 1 - - def test_sync_success_after_retry(self): - """测试同步函数重试后成功""" - from astrbot.core.platform.sources.cli.utils.decorators import retry - - call_count = 0 - - @retry(max_attempts=3, delay=0.01) - def func(): - nonlocal call_count - call_count += 1 - if call_count < 3: - raise ValueError("retry") - return "success" - - assert func() == "success" - assert call_count == 3 - - def test_sync_all_attempts_fail(self): - """测试同步函数所有重试失败""" - from astrbot.core.platform.sources.cli.utils.decorators import retry - - @retry(max_attempts=3, delay=0.01) - def func(): - raise ValueError("always fail") - - with pytest.raises(ValueError): - func() - - @pytest.mark.asyncio - async def test_async_success_after_retry(self): - """测试异步函数重试后成功""" - from astrbot.core.platform.sources.cli.utils.decorators import retry - - call_count = 0 - - @retry(max_attempts=3, delay=0.01) - async def func(): - nonlocal call_count - call_count += 1 - if call_count < 2: - raise ValueError("retry") - return "success" - - assert await func() == "success" - assert call_count == 2 - - -class TestTimeout: - """超时装饰器测试""" - - @pytest.mark.asyncio - async def test_no_timeout(self): - """测试无超时""" - from astrbot.core.platform.sources.cli.utils.decorators import timeout - - @timeout(1.0) - async def func(): - return "success" - - assert await func() == "success" - - @pytest.mark.asyncio - async def test_timeout_exceeded(self): - """测试超时""" - from astrbot.core.platform.sources.cli.utils.decorators import ( - TimeoutError, - timeout, - ) - - @timeout(0.01) - async def func(): - await asyncio.sleep(1.0) - return "success" - - with pytest.raises(TimeoutError): - await func() - - def test_sync_not_supported(self): - """测试同步函数不支持""" - from astrbot.core.platform.sources.cli.utils.decorators import timeout - - with pytest.raises(TypeError): - - @timeout(1.0) - def func(): - return "success" - - -class TestLogEntryExit: - """日志入口出口装饰器测试""" - - def test_sync_function(self): - """测试同步函数""" - from astrbot.core.platform.sources.cli.utils.decorators import log_entry_exit - - @log_entry_exit - def func(): - return "success" - - assert func() == "success" - - @pytest.mark.asyncio - async def test_async_function(self): - """测试异步函数""" - from astrbot.core.platform.sources.cli.utils.decorators import log_entry_exit - - @log_entry_exit - async def func(): - return "success" - - assert await func() == "success" - - def test_sync_with_exception(self): - """测试同步函数异常""" - from astrbot.core.platform.sources.cli.utils.decorators import log_entry_exit - - @log_entry_exit - def func(): - raise ValueError("test") - - with pytest.raises(ValueError): - func() - - -class TestLogPerformance: - """性能日志装饰器测试""" - - def test_sync_under_threshold(self): - """测试同步函数低于阈值""" - from astrbot.core.platform.sources.cli.utils.decorators import log_performance - - @log_performance(threshold_ms=1000.0) - def func(): - return "success" - - assert func() == "success" - - @pytest.mark.asyncio - async def test_async_under_threshold(self): - """测试异步函数低于阈值""" - from astrbot.core.platform.sources.cli.utils.decorators import log_performance - - @log_performance(threshold_ms=1000.0) - async def func(): - return "success" - - assert await func() == "success" - - -class TestRequireAuth: - """权限校验装饰器测试""" - - def test_sync_valid_token(self): - """测试同步函数有效token""" - from astrbot.core.platform.sources.cli.utils.decorators import require_auth - - @require_auth(token_getter=lambda: "valid_token") - def func(auth_token=None): - return "success" - - assert func(auth_token="valid_token") == "success" - - def test_sync_invalid_token(self): - """测试同步函数无效token""" - from astrbot.core.platform.sources.cli.utils.decorators import ( - AuthenticationError, - require_auth, - ) - - @require_auth(token_getter=lambda: "valid_token") - def func(auth_token=None): - return "success" - - with pytest.raises(AuthenticationError): - func(auth_token="wrong_token") - - def test_sync_missing_token(self): - """测试同步函数缺少token""" - from astrbot.core.platform.sources.cli.utils.decorators import ( - AuthenticationError, - require_auth, - ) - - @require_auth(token_getter=lambda: "valid_token") - def func(auth_token=None): - return "success" - - with pytest.raises(AuthenticationError): - func() - - def test_sync_disabled_auth(self): - """测试同步函数禁用验证""" - from astrbot.core.platform.sources.cli.utils.decorators import require_auth - - @require_auth(token_getter=lambda: None) - def func(auth_token=None): - return "success" - - # 禁用验证时任何token都通过 - assert func(auth_token="any") == "success" - assert func() == "success" - - @pytest.mark.asyncio - async def test_async_valid_token(self): - """测试异步函数有效token""" - from astrbot.core.platform.sources.cli.utils.decorators import require_auth - - @require_auth(token_getter=lambda: "valid_token") - async def func(auth_token=None): - return "success" - - assert await func(auth_token="valid_token") == "success" - - -class TestRequireWhitelist: - """白名单校验装饰器测试""" - - def test_sync_in_whitelist(self): - """测试同步函数在白名单中""" - from astrbot.core.platform.sources.cli.utils.decorators import require_whitelist - - @require_whitelist( - whitelist=["user1", "user2"], - id_getter=lambda args, kwargs: kwargs.get("user_id"), - ) - def func(user_id=None): - return "success" - - assert func(user_id="user1") == "success" - - def test_sync_not_in_whitelist(self): - """测试同步函数不在白名单中""" - from astrbot.core.platform.sources.cli.utils.decorators import ( - AuthenticationError, - require_whitelist, - ) - - @require_whitelist( - whitelist=["user1", "user2"], - id_getter=lambda args, kwargs: kwargs.get("user_id"), - ) - def func(user_id=None): - return "success" - - with pytest.raises(AuthenticationError): - func(user_id="user3") - - def test_sync_empty_whitelist(self): - """测试同步函数空白名单（允许所有）""" - from astrbot.core.platform.sources.cli.utils.decorators import require_whitelist - - @require_whitelist(whitelist=[], id_getter=lambda args, kwargs: "any") - def func(): - return "success" - - assert func() == "success" - - -class TestCombinedDecorator: - """组合装饰器测试""" - - def test_with_logging_and_error_handling(self): - """测试组合装饰器""" - from astrbot.core.platform.sources.cli.utils.decorators import ( - with_logging_and_error_handling, - ) - - @with_logging_and_error_handling( - log_entry=True, - handle_errors=True, - default_return="error", - ) - def func(): - raise ValueError("test") - - assert func() == "error" - - def test_with_logging_no_error(self): - """测试组合装饰器无错误""" - from astrbot.core.platform.sources.cli.utils.decorators import ( - with_logging_and_error_handling, - ) - - @with_logging_and_error_handling(log_entry=True, handle_errors=False) - def func(): - return "success" - - assert func() == "success" diff --git a/tests/test_cli/test_e2e.py b/tests/test_cli/test_e2e.py index ff2f3ac26e..32a74c095c 100644 --- a/tests/test_cli/test_e2e.py +++ b/tests/test_cli/test_e2e.py @@ -34,8 +34,10 @@ def mock_config(self): async def test_message_converter_to_event_flow(self): """测试消息转换到事件的完整流程""" from astrbot.core.platform.platform_metadata import PlatformMetadata - from astrbot.core.platform.sources.cli.cli_event import CLIMessageEvent - from astrbot.core.platform.sources.cli.message.converter import MessageConverter + from astrbot.core.platform.sources.cli.cli_event import ( + CLIMessageEvent, + MessageConverter, + ) # 1. 创建消息转换器 converter = MessageConverter() @@ -71,7 +73,7 @@ async def test_response_builder_with_message_chain(self): """测试响应构建器处理消息链""" from astrbot.core.message.components import Image, Plain from astrbot.core.message.message_event_result import MessageChain - from astrbot.core.platform.sources.cli.message.response_builder import ( + from astrbot.core.platform.sources.cli.cli_event import ( ResponseBuilder, ) @@ -98,7 +100,7 @@ async def test_response_builder_with_message_chain(self): @pytest.mark.asyncio async def test_session_lifecycle(self): """测试会话生命周期""" - from astrbot.core.platform.sources.cli.session.session_manager import ( + from astrbot.core.platform.sources.cli.cli_adapter import ( SessionManager, ) @@ -121,12 +123,12 @@ async def test_token_validation_flow(self): """测试Token验证流程""" import tempfile - from astrbot.core.platform.sources.cli.config.token_manager import TokenManager + from astrbot.core.platform.sources.cli.cli_adapter import TokenManager # 使用临时目录避免影响真实token文件 with tempfile.TemporaryDirectory() as tmpdir: with patch( - "astrbot.core.platform.sources.cli.config.token_manager.get_astrbot_data_path" + "astrbot.core.platform.sources.cli.cli_adapter.get_astrbot_data_path" ) as mock_path: mock_path.return_value = tmpdir @@ -153,8 +155,10 @@ async def test_cli_event_send_to_queue(self): from astrbot.core.message.components import Plain from astrbot.core.message.message_event_result import MessageChain from astrbot.core.platform.platform_metadata import PlatformMetadata - from astrbot.core.platform.sources.cli.cli_event import CLIMessageEvent - from astrbot.core.platform.sources.cli.message.converter import MessageConverter + from astrbot.core.platform.sources.cli.cli_event import ( + CLIMessageEvent, + MessageConverter, + ) # 1. 使用MessageConverter创建真实的消息对象 converter = MessageConverter() @@ -195,12 +199,13 @@ async def test_image_processor_pipeline(self): import tempfile from astrbot.core.message.components import Image, Plain - from astrbot.core.platform.sources.cli.message.image_processor import ( - ChainPreprocessor, - ImageExtractor, + from astrbot.core.platform.sources.cli.cli_event import ( ImageProcessor, + preprocess_chain, ) + # ImageExtractor和ChainPreprocessor已合并到ImageProcessor和preprocess_chain + # 1. 创建临时图片文件 with tempfile.NamedTemporaryFile(delete=False, suffix=".png") as f: f.write(b"fake image data") @@ -220,17 +225,17 @@ async def test_image_processor_pipeline(self): ] # 4. 提取图片信息 - images = ImageExtractor.extract(chain) + images = ImageProcessor.extract_images(chain) assert len(images) == 2 assert images[0].type == "url" assert images[0].url == "https://example.com/remote.png" # 5. 预处理消息链（本地文件转base64） local_image = Image(file=f"file:///{temp_path}") - preprocess_chain = MagicMock() - preprocess_chain.chain = [local_image] + preprocess_mock = MagicMock() + preprocess_mock.chain = [local_image] - ChainPreprocessor.preprocess(preprocess_chain) + preprocess_chain(preprocess_mock) # 验证本地文件已转换为base64 assert local_image.file.startswith("base64://") @@ -241,7 +246,7 @@ async def test_image_processor_pipeline(self): @pytest.mark.asyncio async def test_error_response_building(self): """测试错误响应构建""" - from astrbot.core.platform.sources.cli.message.response_builder import ( + from astrbot.core.platform.sources.cli.cli_event import ( ResponseBuilder, ) @@ -266,7 +271,7 @@ async def test_error_response_building(self): @pytest.mark.asyncio async def test_isolated_session_creation(self): """测试隔离会话创建""" - from astrbot.core.platform.sources.cli.message.converter import MessageConverter + from astrbot.core.platform.sources.cli.cli_event import MessageConverter converter = MessageConverter() diff --git a/tests/test_cli/test_image_processor.py b/tests/test_cli/test_image_processor.py index 86242e6983..e8785fbc60 100644 --- a/tests/test_cli/test_image_processor.py +++ b/tests/test_cli/test_image_processor.py @@ -6,68 +6,58 @@ from unittest.mock import MagicMock, patch -class TestImageCodec: - """ImageCodec 测试类""" +class TestImageProcessorBase64: + """base64 编解码测试""" def test_encode(self): """测试 base64 编码""" - from astrbot.core.platform.sources.cli.message.image_processor import ImageCodec - data = b"Hello, World!" - encoded = ImageCodec.encode(data) + encoded = base64.b64encode(data).decode("utf-8") assert encoded == base64.b64encode(data).decode("utf-8") def test_decode(self): """测试 base64 解码""" - from astrbot.core.platform.sources.cli.message.image_processor import ImageCodec - original = b"Hello, World!" encoded = base64.b64encode(original).decode("utf-8") - decoded = ImageCodec.decode(encoded) + decoded = base64.b64decode(encoded) assert decoded == original -class TestImageFileIO: - """ImageFileIO 测试类""" +class TestImageProcessorFileIO: + """文件读写测试""" def test_read_existing_file(self): """测试读取存在的文件""" - from astrbot.core.platform.sources.cli.message.image_processor import ( - ImageFileIO, - ) - with tempfile.NamedTemporaryFile(delete=False) as f: f.write(b"test content") temp_path = f.name try: - data = ImageFileIO.read(temp_path) + with open(temp_path, "rb") as f: + data = f.read() assert data == b"test content" finally: os.unlink(temp_path) def test_read_nonexistent_file(self): """测试读取不存在的文件""" - from astrbot.core.platform.sources.cli.message.image_processor import ( - ImageFileIO, - ) + from astrbot.core.platform.sources.cli.cli_event import ImageProcessor - data = ImageFileIO.read("/nonexistent/path/file.png") - assert data is None + result = ImageProcessor.local_file_to_base64("/nonexistent/path/file.png") + assert result is None - def test_write_temp(self): - """测试写入临时文件""" - from astrbot.core.platform.sources.cli.message.image_processor import ( - ImageFileIO, - ) + def test_base64_to_temp_file(self): + """测试 base64 写入临时文件""" + from astrbot.core.platform.sources.cli.cli_event import ImageProcessor with patch( - "astrbot.core.platform.sources.cli.message.image_processor.get_astrbot_temp_path" + "astrbot.core.platform.sources.cli.cli_event.get_astrbot_temp_path" ) as mock_temp: mock_temp.return_value = tempfile.gettempdir() data = b"test image data" - temp_path = ImageFileIO.write_temp(data, suffix=".png") + base64_data = base64.b64encode(data).decode("utf-8") + temp_path = ImageProcessor.base64_to_temp_file(base64_data) assert temp_path is not None assert os.path.exists(temp_path) @@ -83,7 +73,7 @@ class TestImageInfo: def test_to_dict_url(self): """测试 URL 类型转字典""" - from astrbot.core.platform.sources.cli.message.image_processor import ImageInfo + from astrbot.core.platform.sources.cli.cli_event import ImageInfo info = ImageInfo(type="url", url="https://example.com/image.png") result = info.to_dict() @@ -93,7 +83,7 @@ def test_to_dict_url(self): def test_to_dict_file(self): """测试文件类型转字典""" - from astrbot.core.platform.sources.cli.message.image_processor import ImageInfo + from astrbot.core.platform.sources.cli.cli_event import ImageInfo info = ImageInfo(type="file", path="/path/to/image.png", size=1024) result = info.to_dict() @@ -104,7 +94,7 @@ def test_to_dict_file(self): def test_to_dict_with_error(self): """测试带错误信息转字典""" - from astrbot.core.platform.sources.cli.message.image_processor import ImageInfo + from astrbot.core.platform.sources.cli.cli_event import ImageInfo info = ImageInfo(type="file", error="Failed to read") result = info.to_dict() @@ -118,14 +108,12 @@ class TestImageExtractor: def test_extract_url_image(self): """测试提取 URL 图片""" from astrbot.core.message.components import Image - from astrbot.core.platform.sources.cli.message.image_processor import ( - ImageExtractor, - ) + from astrbot.core.platform.sources.cli.cli_event import ImageProcessor chain = MagicMock() chain.chain = [Image(file="https://example.com/image.png")] - images = ImageExtractor.extract(chain) + images = ImageProcessor.extract_images(chain) assert len(images) == 1 assert images[0].type == "url" @@ -133,22 +121,18 @@ def test_extract_url_image(self): def test_extract_empty_chain(self): """测试提取空消息链""" - from astrbot.core.platform.sources.cli.message.image_processor import ( - ImageExtractor, - ) + from astrbot.core.platform.sources.cli.cli_event import ImageProcessor chain = MagicMock() chain.chain = [] - images = ImageExtractor.extract(chain) + images = ImageProcessor.extract_images(chain) assert len(images) == 0 def test_extract_mixed_components(self): """测试提取混合组件""" from astrbot.core.message.components import Image, Plain - from astrbot.core.platform.sources.cli.message.image_processor import ( - ImageExtractor, - ) + from astrbot.core.platform.sources.cli.cli_event import ImageProcessor chain = MagicMock() chain.chain = [ @@ -158,7 +142,7 @@ def test_extract_mixed_components(self): Image(file="https://example.com/2.png"), ] - images = ImageExtractor.extract(chain) + images = ImageProcessor.extract_images(chain) assert len(images) == 2 assert images[0].url == "https://example.com/1.png" @@ -171,9 +155,7 @@ class TestChainPreprocessor: def test_preprocess_local_file(self): """测试预处理本地文件图片""" from astrbot.core.message.components import Image - from astrbot.core.platform.sources.cli.message.image_processor import ( - ChainPreprocessor, - ) + from astrbot.core.platform.sources.cli.cli_event import preprocess_chain # 创建临时图片文件 with tempfile.NamedTemporaryFile(delete=False, suffix=".png") as f: @@ -185,7 +167,7 @@ def test_preprocess_local_file(self): image = Image(file=f"file:///{temp_path}") chain.chain = [image] - ChainPreprocessor.preprocess(chain) + preprocess_chain(chain) # 验证已转换为 base64 assert image.file.startswith("base64://") @@ -198,15 +180,13 @@ def test_preprocess_local_file(self): def test_preprocess_url_unchanged(self): """测试 URL 图片不变""" from astrbot.core.message.components import Image - from astrbot.core.platform.sources.cli.message.image_processor import ( - ChainPreprocessor, - ) + from astrbot.core.platform.sources.cli.cli_event import preprocess_chain chain = MagicMock() image = Image(file="https://example.com/image.png") chain.chain = [image] - ChainPreprocessor.preprocess(chain) + preprocess_chain(chain) # URL 应保持不变 assert image.file == "https://example.com/image.png" @@ -217,9 +197,7 @@ class TestImageProcessor: def test_local_file_to_base64(self): """测试本地文件转 base64""" - from astrbot.core.platform.sources.cli.message.image_processor import ( - ImageProcessor, - ) + from astrbot.core.platform.sources.cli.cli_event import ImageProcessor with tempfile.NamedTemporaryFile(delete=False) as f: f.write(b"test data") @@ -233,9 +211,7 @@ def test_local_file_to_base64(self): def test_local_file_to_base64_nonexistent(self): """测试不存在的文件""" - from astrbot.core.platform.sources.cli.message.image_processor import ( - ImageProcessor, - ) + from astrbot.core.platform.sources.cli.cli_event import ImageProcessor result = ImageProcessor.local_file_to_base64("/nonexistent/file.png") assert result is None diff --git a/tests/test_cli/test_message_converter.py b/tests/test_cli/test_message_converter.py index 838d9a723c..98ee0ca6d8 100644 --- a/tests/test_cli/test_message_converter.py +++ b/tests/test_cli/test_message_converter.py @@ -10,7 +10,7 @@ class TestMessageConverter: @pytest.fixture def converter(self): """创建 MessageConverter 实例""" - from astrbot.core.platform.sources.cli.message.converter import MessageConverter + from astrbot.core.platform.sources.cli.cli_event import MessageConverter return MessageConverter() @@ -70,7 +70,7 @@ def test_convert_message_has_plain_component(self, converter): def test_custom_default_session_id(self): """测试自定义默认 session_id""" - from astrbot.core.platform.sources.cli.message.converter import MessageConverter + from astrbot.core.platform.sources.cli.cli_event import MessageConverter converter = MessageConverter(default_session_id="custom_session") message = converter.convert("Test") @@ -79,7 +79,7 @@ def test_custom_default_session_id(self): def test_custom_user_info(self): """测试自定义用户信息""" - from astrbot.core.platform.sources.cli.message.converter import MessageConverter + from astrbot.core.platform.sources.cli.cli_event import MessageConverter converter = MessageConverter( user_id="custom_user", diff --git a/tests/test_cli/test_response_builder.py b/tests/test_cli/test_response_builder.py index 31a7a4f3de..90c3f4b3be 100644 --- a/tests/test_cli/test_response_builder.py +++ b/tests/test_cli/test_response_builder.py @@ -19,7 +19,7 @@ def mock_message_chain(self): def test_build_success_basic(self, mock_message_chain): """测试构建基本成功响应""" - from astrbot.core.platform.sources.cli.message.response_builder import ( + from astrbot.core.platform.sources.cli.cli_event import ( ResponseBuilder, ) @@ -33,7 +33,7 @@ def test_build_success_basic(self, mock_message_chain): def test_build_success_with_extra(self, mock_message_chain): """测试构建带额外字段的成功响应""" - from astrbot.core.platform.sources.cli.message.response_builder import ( + from astrbot.core.platform.sources.cli.cli_event import ( ResponseBuilder, ) @@ -45,7 +45,7 @@ def test_build_success_with_extra(self, mock_message_chain): def test_build_error_basic(self): """测试构建基本错误响应""" - from astrbot.core.platform.sources.cli.message.response_builder import ( + from astrbot.core.platform.sources.cli.cli_event import ( ResponseBuilder, ) @@ -58,7 +58,7 @@ def test_build_error_basic(self): def test_build_error_with_request_id(self): """测试构建带 request_id 的错误响应""" - from astrbot.core.platform.sources.cli.message.response_builder import ( + from astrbot.core.platform.sources.cli.cli_event import ( ResponseBuilder, ) @@ -69,7 +69,7 @@ def test_build_error_with_request_id(self): def test_build_error_with_error_code(self): """测试构建带错误代码的错误响应""" - from astrbot.core.platform.sources.cli.message.response_builder import ( + from astrbot.core.platform.sources.cli.cli_event import ( ResponseBuilder, ) @@ -83,7 +83,7 @@ def test_build_error_with_error_code(self): def test_build_success_with_url_image(self): """测试构建带 URL 图片的成功响应""" from astrbot.core.message.components import Image - from astrbot.core.platform.sources.cli.message.response_builder import ( + from astrbot.core.platform.sources.cli.cli_event import ( ResponseBuilder, ) @@ -103,7 +103,7 @@ def test_build_success_with_url_image(self): def test_build_success_chinese_text(self, mock_message_chain): """测试构建中文文本响应""" - from astrbot.core.platform.sources.cli.message.response_builder import ( + from astrbot.core.platform.sources.cli.cli_event import ( ResponseBuilder, ) diff --git a/tests/test_cli/test_token_manager.py b/tests/test_cli/test_token_manager.py index 897e3855d5..0464adbbaa 100644 --- a/tests/test_cli/test_token_manager.py +++ b/tests/test_cli/test_token_manager.py @@ -20,12 +20,10 @@ def temp_data_path(self): def token_manager(self, temp_data_path): """创建 TokenManager 实例""" with patch( - "astrbot.core.platform.sources.cli.config.token_manager.get_astrbot_data_path", + "astrbot.core.platform.sources.cli.cli_adapter.get_astrbot_data_path", return_value=temp_data_path, ): - from astrbot.core.platform.sources.cli.config.token_manager import ( - TokenManager, - ) + from astrbot.core.platform.sources.cli.cli_adapter import TokenManager return TokenManager() @@ -48,12 +46,10 @@ def test_load_existing_token(self, temp_data_path): f.write(expected_token) with patch( - "astrbot.core.platform.sources.cli.config.token_manager.get_astrbot_data_path", + "astrbot.core.platform.sources.cli.cli_adapter.get_astrbot_data_path", return_value=temp_data_path, ): - from astrbot.core.platform.sources.cli.config.token_manager import ( - TokenManager, - ) + from astrbot.core.platform.sources.cli.cli_adapter import TokenManager manager = TokenManager() assert manager.token == expected_token @@ -76,12 +72,10 @@ def test_validate_empty_token(self, token_manager): def test_validate_without_server_token(self, temp_data_path): """测试服务器无 Token 时跳过验证""" with patch( - "astrbot.core.platform.sources.cli.config.token_manager.get_astrbot_data_path", + "astrbot.core.platform.sources.cli.cli_adapter.get_astrbot_data_path", return_value=temp_data_path, ): - from astrbot.core.platform.sources.cli.config.token_manager import ( - TokenManager, - ) + from astrbot.core.platform.sources.cli.cli_adapter import TokenManager manager = TokenManager() # 模拟 _ensure_token 返回 None（Token 生成失败场景） @@ -99,12 +93,10 @@ def test_regenerate_empty_token_file(self, temp_data_path): f.write("") with patch( - "astrbot.core.platform.sources.cli.config.token_manager.get_astrbot_data_path", + "astrbot.core.platform.sources.cli.cli_adapter.get_astrbot_data_path", return_value=temp_data_path, ): - from astrbot.core.platform.sources.cli.config.token_manager import ( - TokenManager, - ) + from astrbot.core.platform.sources.cli.cli_adapter import TokenManager manager = TokenManager() token = manager.token From 3a7508e64fea6367549f7e656214947da301edca Mon Sep 17 00:00:00 2001 From: YukiRa1n <167516635+YukiRa1n@users.noreply.github.com> Date: Thu, 19 Feb 2026 21:50:55 +0800 Subject: [PATCH 33/39] ci: exclude test_cli from default pytest run --- pyproject.toml | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/pyproject.toml b/pyproject.toml index 82fb0d33e2..da9e0dab21 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -111,6 +111,10 @@ reportMissingImports = false include = ["astrbot"] exclude = ["dashboard", "node_modules", "dist", "data", "tests"] +[tool.pytest.ini_options] +asyncio_mode = "strict" +addopts = "--ignore=tests/test_cli" + [build-system] requires = ["hatchling"] build-backend = "hatchling.build" From 632a54a3f2d4353283eb78846b7abfaf443699e6 Mon Sep 17 00:00:00 2001 From: YukiRa1n <167516635+YukiRa1n@users.noreply.github.com> Date: Thu, 19 Feb 2026 23:15:41 +0800 Subject: [PATCH 34/39] feat(cli): add function tool listing and calling via astr tool MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit 通过 socket action 协议在 CLI 适配器中实现函数工具管理， 支持 astr tool ls/info/call 子命令，无需注册为全局指令。 --- astrbot/cli/client/__main__.py | 6 + astrbot/cli/client/commands/__init__.py | 4 + astrbot/cli/client/commands/tool.py | 133 ++++ astrbot/cli/client/connection.py | 54 ++ .../platform/sources/cli/socket_handler.py | 126 ++++ astrbot/core/provider/func_tool_manager.py | 11 + tests/test_cli/test_client_e2e.py | 652 +++++------------- 7 files changed, 505 insertions(+), 481 deletions(-) create mode 100644 astrbot/cli/client/commands/tool.py diff --git a/astrbot/cli/client/__main__.py b/astrbot/cli/client/__main__.py index f5656c98e3..579f013406 100644 --- a/astrbot/cli/client/__main__.py +++ b/astrbot/cli/client/__main__.py @@ -87,6 +87,12 @@ 例: astr test plugin probe cpu → 实际发送 /probe cpu + [函数工具] astr tool <子命令> + astr tool ls 列出所有注册的函数工具 + astr tool ls -o plugin 按来源过滤（plugin/mcp/builtin） + astr tool info 查看工具详细信息和参数 + astr tool call [json] 调用工具，例: astr tool call my_func '{"k":"v"}' + [交互模式] astr interactive 进入 REPL 模式（支持命令历史） astr -i 同上（快捷方式） diff --git a/astrbot/cli/client/commands/__init__.py b/astrbot/cli/client/commands/__init__.py index c71931b310..d24965fed6 100644 --- a/astrbot/cli/client/commands/__init__.py +++ b/astrbot/cli/client/commands/__init__.py @@ -9,6 +9,7 @@ from .plugin import plugin from .provider import key, model, provider from .send import send +from .tool import tool def register_commands(group): @@ -37,6 +38,9 @@ def register_commands(group): group.add_command(status) group.add_command(test) + # 函数工具管理 + group.add_command(tool) + # 交互模式 group.add_command(interactive) diff --git a/astrbot/cli/client/commands/tool.py b/astrbot/cli/client/commands/tool.py new file mode 100644 index 0000000000..ebd01075a9 --- /dev/null +++ b/astrbot/cli/client/commands/tool.py @@ -0,0 +1,133 @@ +"""函数工具管理命令组 - astr tool""" + +import json +import sys + +import click + +from ..connection import call_tool, list_tools + + +@click.group(help="函数工具管理 (子命令: ls/info/call)") +def tool() -> None: + """函数工具管理命令组""" + + +@tool.command(name="ls", help="列出所有注册的函数工具") +@click.option( + "--origin", "-o", type=str, default="", help="按来源过滤: plugin/mcp/builtin" +) +@click.option("-j", "--json-output", "use_json", is_flag=True, help="输出原始 JSON") +def tool_ls(origin: str, use_json: bool) -> None: + """列出所有注册的函数工具""" + resp = list_tools() + + if resp.get("status") != "success": + click.echo(f"[ERROR] {resp.get('error', 'Unknown error')}", err=True) + sys.exit(1) + + tools = resp.get("tools", []) + if not tools: + raw = resp.get("response", "") + if raw: + try: + tools = json.loads(raw) + except (json.JSONDecodeError, TypeError): + pass + + if origin: + tools = [ + t + for t in tools + if t.get("origin") == origin or t.get("origin_name") == origin + ] + + if use_json: + click.echo(json.dumps(tools, ensure_ascii=False, indent=2)) + return + + if not tools: + click.echo("没有注册的函数工具。") + return + + click.echo(f"{'名称':<25} {'来源':<10} {'来源名':<18} {'状态':<6} {'描述'}") + click.echo("-" * 90) + for t in tools: + name = t.get("name", "?") + ori = t.get("origin", "?") + ori_name = t.get("origin_name", "?") + active = "启用" if t.get("active", True) else "停用" + desc = (t.get("description") or "")[:40] + click.echo(f"{name:<25} {ori:<10} {ori_name:<18} {active:<6} {desc}") + + click.echo(f"\n共 {len(tools)} 个工具") + + +@tool.command(name="info", help="查看工具详细信息") +@click.argument("name") +def tool_info(name: str) -> None: + """查看工具详细信息""" + resp = list_tools() + + if resp.get("status") != "success": + click.echo(f"[ERROR] {resp.get('error', 'Unknown error')}", err=True) + sys.exit(1) + + tools = resp.get("tools", []) + if not tools: + raw = resp.get("response", "") + if raw: + try: + tools = json.loads(raw) + except (json.JSONDecodeError, TypeError): + pass + + matched = [t for t in tools if t.get("name") == name] + if not matched: + click.echo(f"未找到工具: {name}") + sys.exit(1) + + t = matched[0] + click.echo(f"名称: {t.get('name')}") + click.echo(f"描述: {t.get('description', '无')}") + click.echo(f"来源: {t.get('origin', '?')} ({t.get('origin_name', '?')})") + click.echo(f"状态: {'启用' if t.get('active', True) else '停用'}") + + params = t.get("parameters") + if params: + click.echo("参数:") + props = params.get("properties", {}) + required = params.get("required", []) + for pname, pinfo in props.items(): + req_mark = "*" if pname in required else " " + ptype = pinfo.get("type", "any") + pdesc = pinfo.get("description", "") + click.echo(f" {req_mark} {pname} ({ptype}): {pdesc}") + + +@tool.command(name="call", help="调用指定的函数工具") +@click.argument("name") +@click.argument("args_json", required=False, default="{}") +@click.option("-t", "--timeout", type=float, default=60.0, help="超时时间（秒）") +def tool_call(name: str, args_json: str, timeout: float) -> None: + """调用指定的函数工具 + + ARGS_JSON: JSON 格式的参数，例如 '{"key": "value"}' + """ + try: + tool_args = json.loads(args_json) + except json.JSONDecodeError as e: + click.echo(f"[ERROR] 参数 JSON 格式错误: {e}", err=True) + sys.exit(1) + + if not isinstance(tool_args, dict): + click.echo("[ERROR] 参数必须是 JSON 对象", err=True) + sys.exit(1) + + resp = call_tool(name, tool_args, timeout=timeout) + + if resp.get("status") != "success": + click.echo(f"[ERROR] {resp.get('error', 'Unknown error')}", err=True) + sys.exit(1) + + click.echo(resp.get("response", "(无返回值)")) diff --git a/astrbot/cli/client/connection.py b/astrbot/cli/client/connection.py index 373e705282..db1e83d3fc 100644 --- a/astrbot/cli/client/connection.py +++ b/astrbot/cli/client/connection.py @@ -302,3 +302,57 @@ def get_logs( return {"status": "error", "error": f"Communication error: {e}"} finally: client_socket.close() + + +def _send_action_request( + action: str, + extra_fields: dict | None = None, + socket_path: str | None = None, + timeout: float = 30.0, +) -> dict: + """发送 action 请求的通用方法""" + auth_token = load_auth_token() + + request: dict = {"action": action, "request_id": str(uuid.uuid4())} + if auth_token: + request["auth_token"] = auth_token + if extra_fields: + request.update(extra_fields) + + try: + client_socket = _get_connected_socket(socket_path, timeout) + except (ValueError, ConnectionError) as e: + return {"status": "error", "error": str(e)} + except Exception as e: + return {"status": "error", "error": f"Connection error: {e}"} + + try: + request_data = json.dumps(request, ensure_ascii=False).encode("utf-8") + client_socket.sendall(request_data) + return _receive_json_response(client_socket) + except TimeoutError: + return {"status": "error", "error": "Request timeout"} + except Exception as e: + return {"status": "error", "error": f"Communication error: {e}"} + finally: + client_socket.close() + + +def list_tools(socket_path: str | None = None, timeout: float = 30.0) -> dict: + """列出所有注册的函数工具""" + return _send_action_request("list_tools", socket_path=socket_path, timeout=timeout) + + +def call_tool( + tool_name: str, + tool_args: dict | None = None, + socket_path: str | None = None, + timeout: float = 60.0, +) -> dict: + """调用指定的函数工具""" + return _send_action_request( + "call_tool", + extra_fields={"tool_name": tool_name, "tool_args": tool_args or {}}, + socket_path=socket_path, + timeout=timeout, + ) diff --git a/astrbot/core/platform/sources/cli/socket_handler.py b/astrbot/core/platform/sources/cli/socket_handler.py index 61c2e51c31..0ba07915d3 100644 --- a/astrbot/core/platform/sources/cli/socket_handler.py +++ b/astrbot/core/platform/sources/cli/socket_handler.py @@ -8,6 +8,7 @@ import os import re import tempfile +import traceback import uuid from collections.abc import Callable from typing import TYPE_CHECKING, Any @@ -168,6 +169,10 @@ async def handle(self, client_socket) -> None: if action == "get_logs": response = await self._get_logs(request, request_id) + elif action == "list_tools": + response = self._list_tools(request_id) + elif action == "call_tool": + response = await self._call_tool(request, request_id) else: message_text = request.get("message", "") response = await self._process_message(message_text, request_id) @@ -325,6 +330,127 @@ async def _get_logs(self, request: dict, request_id: str) -> str: logger.exception("[CLI] Error getting logs") return _build_error_response(f"Error getting logs: {e}", request_id) + # ------------------------------------------------------------------ + # 函数工具管理（CLI专属） + # ------------------------------------------------------------------ + + def _list_tools(self, request_id: str) -> str: + """列出所有注册的函数工具""" + from astrbot.core.provider.func_tool_manager import get_func_tool_manager + + tool_mgr = get_func_tool_manager() + if tool_mgr is None: + return _build_error_response("FunctionToolManager 未初始化", request_id) + + tools = [] + for tool in tool_mgr.func_list: + # 判断来源 + origin = "unknown" + origin_name = "unknown" + try: + from astrbot.core.agent.mcp_client import MCPTool + from astrbot.core.star.star import star_map + + if isinstance(tool, MCPTool): + origin = "mcp" + origin_name = tool.mcp_server_name + elif tool.handler_module_path and star_map.get( + tool.handler_module_path + ): + origin = "plugin" + origin_name = star_map[tool.handler_module_path].name + else: + origin = "builtin" + origin_name = "builtin" + except Exception: + pass + + tools.append( + { + "name": tool.name, + "description": tool.description, + "parameters": tool.parameters, + "active": tool.active, + "origin": origin, + "origin_name": origin_name, + } + ) + + return json.dumps( + { + "status": "success", + "response": json.dumps(tools, ensure_ascii=False, indent=2), + "tools": tools, + "images": [], + "request_id": request_id, + }, + ensure_ascii=False, + ) + + async def _call_tool(self, request: dict, request_id: str) -> str: + """调用指定的函数工具""" + from astrbot.core.provider.func_tool_manager import get_func_tool_manager + + tool_mgr = get_func_tool_manager() + if tool_mgr is None: + return _build_error_response("FunctionToolManager 未初始化", request_id) + + tool_name = request.get("tool_name", "") + tool_args = request.get("tool_args", {}) + + if not tool_name: + return _build_error_response("缺少 tool_name 参数", request_id) + + tool = tool_mgr.get_func(tool_name) + if tool is None: + return _build_error_response(f"未找到工具: {tool_name}", request_id) + + if not tool.active: + return _build_error_response(f"工具 {tool_name} 当前已停用", request_id) + + if tool.handler is None: + return _build_error_response( + f"工具 {tool_name} 没有可调用的处理函数", request_id + ) + + try: + # 构造一个最小化的 event 用于工具调用 + from .cli_event import CLIMessageEvent + + response_future = asyncio.Future() + message = self.message_converter.convert( + f"/tool call {tool_name}", + request_id=request_id, + use_isolated_session=self.use_isolated_sessions, + ) + event = CLIMessageEvent( + message_str=message.message_str, + message_obj=message, + platform_meta=self.platform_meta, + session_id=message.session_id, + output_queue=self.output_queue, + response_future=response_future, + ) + + result = await tool.handler(event, **tool_args) + result_text = str(result) if result is not None else "(无返回值)" + + return json.dumps( + { + "status": "success", + "response": result_text, + "images": [], + "request_id": request_id, + }, + ensure_ascii=False, + ) + except Exception as e: + logger.error(f"[CLI] Tool call error: {tool_name}: {e}") + return _build_error_response( + f"调用工具 {tool_name} 失败: {e}\n{traceback.format_exc()[-300:]}", + request_id, + ) + # ------------------------------------------------------------------ # Socket模式处理器 diff --git a/astrbot/core/provider/func_tool_manager.py b/astrbot/core/provider/func_tool_manager.py index 106b42cc5b..9aa0814943 100644 --- a/astrbot/core/provider/func_tool_manager.py +++ b/astrbot/core/provider/func_tool_manager.py @@ -103,8 +103,19 @@ async def _quick_test_mcp_connection(config: dict) -> tuple[bool, str]: return False, f"{e!s}" +# 模块级单例引用，供无法通过依赖注入获取实例的模块使用（如CLI适配器） +_global_instance: FunctionToolManager | None = None + + +def get_func_tool_manager() -> FunctionToolManager | None: + """获取全局 FunctionToolManager 实例""" + return _global_instance + + class FunctionToolManager: def __init__(self) -> None: + global _global_instance + _global_instance = self self.func_list: list[FuncTool] = [] self.mcp_client_dict: dict[str, MCPClient] = {} """MCP 服务列表""" diff --git a/tests/test_cli/test_client_e2e.py b/tests/test_cli/test_client_e2e.py index 0edb8c26ad..98d70f17dd 100644 --- a/tests/test_cli/test_client_e2e.py +++ b/tests/test_cli/test_client_e2e.py @@ -1,24 +1,15 @@ -"""CLI Client 长链条端到端测试 +"""CLI Client 端到端测试 -对框架各子模块按 SDK 粒度进行端到端测试。 不使用 mock，直接通过真实 socket 连接到运行中的 AstrBot 服务端。 - 测试前提：AstrBot 已启动并开启 CLI 平台适配器（socket 模式）。 -测试链路覆盖： - 客户端 connection 模块 - → TCP/Unix Socket 连接 - → Token 认证 - → SocketClientHandler.handle() - → MessageConverter.convert() - → CLIMessageEvent (事件创建/提交/finalize) - → Pipeline (内置命令/LLM/插件) - → ResponseBuilder.build_success/build_error - → 客户端 output 模块解析 - -运行方式： - pytest tests/test_cli/test_client_e2e.py -v # 需要 AstrBot 服务端运行 - pytest tests/test_cli/ --ignore=tests/test_cli/test_client_e2e.py # 只跑单元测试 +设计原则： + - 零重复：每个命令在整个文件中只发送一次 + - 行为测试与命令测试分离：行为测试（稳定性/并发）不重复验证命令内容 + - 纯函数用 fake 数据，不调服务端 + +运行方式（已从默认 pytest 排除，需手动指定）： + pytest tests/test_cli/test_client_e2e.py -v --override-ini="addopts=" """ import os @@ -27,22 +18,19 @@ import pytest from astrbot.cli.client.connection import ( + call_tool, get_data_path, get_logs, + list_tools, load_auth_token, load_connection_info, send_message, ) from astrbot.cli.client.output import format_response -# 默认超时（秒）：内置命令应在此时间内返回 -_CMD_TIMEOUT = 30.0 -# LLM 管道超时（秒）：触发 LLM 的命令可能更慢 -_LLM_TIMEOUT = 60.0 - def _server_reachable() -> bool: - """检查 AstrBot 服务端是否可达""" + """检查服务端是否可达（整个文件唯一的探测调用）""" try: resp = send_message("/help", timeout=10.0) return resp.get("status") == "success" @@ -50,20 +38,6 @@ def _server_reachable() -> bool: return False -def _send_with_retry(message: str, retries: int = 3, delay: float = 1.0, **kwargs) -> dict: - """发送消息，失败时自动重试（应对服务端短暂繁忙）""" - last_resp = None - for i in range(retries): - resp = send_message(message, **kwargs) - if resp.get("status") == "success": - return resp - last_resp = resp - if i < retries - 1: - time.sleep(delay) - return last_resp - - -# 如果服务端不可达，跳过所有测试 pytestmark = [ pytest.mark.skipif( not _server_reachable(), @@ -74,554 +48,270 @@ def _send_with_retry(message: str, retries: int = 3, delay: float = 1.0, **kwarg # ============================================================ -# 第一层：连接基础设施测试 +# 第一层：连接基础设施（纯本地检查，0 次服务端调用） # ============================================================ class TestConnectionInfra: - """连接基础设施端到端测试 - - 验证链路：客户端 → 连接文件 → Token → Socket 建立 - """ + """验证本地配置文件：数据目录、连接信息、Token""" def test_data_path_exists(self): - """数据目录存在且可读""" data_dir = get_data_path() assert os.path.isdir(data_dir), f"数据目录不存在: {data_dir}" def test_connection_info_valid(self): - """连接信息文件存在且格式正确""" data_dir = get_data_path() info = load_connection_info(data_dir) - assert info is not None, "连接信息文件 .cli_connection 不存在" - assert "type" in info, "连接信息缺少 type 字段" + assert info is not None, ".cli_connection 不存在" assert info["type"] in ("unix", "tcp"), f"未知连接类型: {info['type']}" - if info["type"] == "tcp": - assert "host" in info - assert "port" in info - assert isinstance(info["port"], int) + assert "host" in info and isinstance(info["port"], int) elif info["type"] == "unix": assert "path" in info def test_auth_token_configured(self): - """Token 已配置且非空""" token = load_auth_token() - assert token, "Token 未配置（.cli_token 为空或不存在）" - assert len(token) > 8, f"Token 过短（{len(token)} 字符），疑似无效" - - def test_socket_roundtrip_latency(self): - """Socket 往返延迟合理（<10s）""" - start = time.time() - resp = send_message("/help") - elapsed = time.time() - start - - assert resp["status"] == "success" - assert elapsed < 10.0, f"Socket 往返延迟过大: {elapsed:.2f}s" + assert token and len(token) > 8, "Token 未配置或过短" # ============================================================ -# 第二层：Token 认证链路测试 +# 第二层：命令管道（每个命令只调用一次） +# +# 服务端调用：/help, /sid ×2, /model, /key, /plugin ls, +# /plugin help builtin_commands = 8 次 # ============================================================ -class TestTokenAuth: - """Token 认证端到端测试 +class TestCommandPipeline: + """每个内置命令只测一次，一次性验证结构+内容+认证""" - 验证链路： - 客户端 auth_token → SocketClientHandler → TokenManager.validate() - """ - - def test_valid_token_accepted(self): - """正确 Token 通过认证""" + def test_help(self): + """/help — 响应结构、内容、延迟、认证（最全面的单命令测试）""" + start = time.time() resp = send_message("/help") - assert resp["status"] == "success" - # 如果 Token 无效会返回 AUTH_FAILED - assert resp.get("error_code") != "AUTH_FAILED" + elapsed = time.time() - start - def test_response_has_request_id(self): - """响应包含 request_id（证明请求通过了完整链路）""" - resp = send_message("/help") - assert "request_id" in resp, "响应缺少 request_id" + assert resp["status"] == "success" + assert "response" in resp and "images" in resp and "request_id" in resp + assert isinstance(resp["images"], list) assert len(resp["request_id"]) > 0 + assert "/help" in resp["response"] + assert elapsed < 10.0, f"延迟过大: {elapsed:.2f}s" + assert resp.get("error_code") != "AUTH_FAILED" + def test_sid_and_consistency(self): + """/sid — 内容正确 + 两次调用返回相同结果（会话一致性）""" + resp1 = send_message("/sid") + resp2 = send_message("/sid") + assert resp1["status"] == "success" and resp2["status"] == "success" + text = resp1["response"] + assert "cli_session" in text or "cli_user" in text or "UMO" in text + assert resp1["response"] == resp2["response"], "会话信息不一致" -# ============================================================ -# 第三层：消息转换与事件链路测试 -# ============================================================ - - -class TestMessagePipeline: - """消息处理管道端到端测试 - - 验证链路： - MessageConverter.convert() → CLIMessageEvent 创建 - → event_committer 提交 → Pipeline 处理 - → CLIMessageEvent.send() 缓冲 → finalize() - → ResponseBuilder.build_success() - """ - - def test_internal_command_help(self): - """/help 命令走完整管道并返回内置命令列表""" - resp = send_message("/help") + def test_model(self): + """/model — 模型列表""" + resp = send_message("/model") assert resp["status"] == "success" - text = resp["response"] - # /help 应返回内置指令列表 - assert "/help" in text, "响应中应包含 /help 指令说明" - assert "内置指令" in text or "帮助" in text or "AstrBot" in text + assert resp["response"] or resp["images"] - def test_internal_command_sid(self): - """/sid 返回会话信息，验证 MessageConverter 的 session_id 设置""" - resp = send_message("/sid") + def test_key(self): + """/key — Key 信息""" + resp = send_message("/key") assert resp["status"] == "success" text = resp["response"] - # /sid 应返回会话 ID 信息 - assert "cli_session" in text or "cli_user" in text or "UMO" in text - - def test_response_structure(self): - """响应结构符合 ResponseBuilder 输出格式""" - resp = send_message("/help") - assert resp["status"] == "success" - # ResponseBuilder.build_success 输出这些字段 - assert "response" in resp - assert "images" in resp - assert isinstance(resp["images"], list) - assert "request_id" in resp + assert "Key" in text or "key" in text.lower() or "当前" in text - @pytest.mark.timeout(_LLM_TIMEOUT) - def test_plain_text_message(self): - """普通文本消息走 LLM 管道""" - resp = send_message("echo test 12345", timeout=_LLM_TIMEOUT) + def test_plugin_ls(self): + """/plugin ls — 插件列表""" + resp = send_message("/plugin ls") assert resp["status"] == "success" - # LLM 或插件应该返回某种响应（不是空的） - assert resp["response"] or resp["images"] + assert "插件" in resp["response"] or "plugin" in resp["response"].lower() - def test_empty_response_for_unknown_command(self): - """不存在的斜杠命令返回某种错误提示""" - resp = send_message("/nonexistent_cmd_xyz_123") + def test_plugin_help(self): + """/plugin help — 指定插件帮助""" + resp = send_message("/plugin help builtin_commands") assert resp["status"] == "success" - # 内置命令系统通常会返回 "未知指令" 之类的提示 - # 或者当作普通消息走 LLM 管道 + text = resp["response"] + assert "指令" in text or "帮助" in text or "help" in text.lower() # ============================================================ -# 第四层：会话管理端到端测试 +# 第三层：会话管理生命周期 +# +# 服务端调用：/new, /rename, /ls, /reset, /history, /del, +# /new, /switch 1, /del = 9 次 # ============================================================ class TestSessionManagement: - """会话管理端到端测试 - - 验证链路： - /new → /ls → /switch → /rename → /history → /reset → /del - 所有命令在同一个 cli_session 上操作对话列表 - - 会话逻辑说明： - - 默认 use_isolated_sessions=False - - 所有 CLI 请求使用同一个 session_id: "cli_session" - - /new, /switch, /del 等操作的是"对话"（LLM上下文），不是 socket 会话 - """ - - def test_conversation_full_lifecycle(self): - """完整对话生命周期：创建 → 列表 → 重命名 → 历史 → 重置 → 删除""" - - # 1. 记住初始状态 - resp_ls_before = send_message("/ls") - assert resp_ls_before["status"] == "success" - - # 2. 创建新对话 - resp_new = send_message("/new") - assert resp_new["status"] == "success" - text_new = resp_new["response"] - assert "新对话" in text_new or "切换" in text_new - - # 3. 重命名 - test_name = "e2e_lifecycle_test" - resp_rename = send_message(f"/rename {test_name}") - assert resp_rename["status"] == "success" - assert "重命名" in resp_rename["response"] or "成功" in resp_rename["response"] - - # 4. 列表中应该能看到新对话 - resp_ls = send_message("/ls") - assert resp_ls["status"] == "success" - assert test_name in resp_ls["response"] - - # 5. 重置 LLM 会话 - resp_reset = send_message("/reset") - assert resp_reset["status"] == "success" - assert "清除" in resp_reset["response"] or "成功" in resp_reset["response"] - - # 6. 查看历史（重置后应为空或只有系统消息） - resp_history = send_message("/history") - assert resp_history["status"] == "success" - - # 7. 删除对话 - resp_del = send_message("/del") - assert resp_del["status"] == "success" - assert "删除" in resp_del["response"] or "成功" in resp_del["response"] - - def test_conversation_switch(self): - """对话切换：创建新对话后切换回旧对话""" - - # 确保有至少一个对话 - send_message("/new") - - # 列表 - resp_ls = send_message("/ls") - assert resp_ls["status"] == "success" - - # 切换到序号 1 - resp_switch = send_message("/switch 1") - assert resp_switch["status"] == "success" - assert "切换" in resp_switch["response"] - - # 清理 - send_message("/del") - - def test_session_id_consistency(self): - """/sid 在多次请求间返回相同会话信息（证明使用同一会话）""" - resp1 = send_message("/sid") - resp2 = send_message("/sid") - assert resp1["status"] == "success" - assert resp2["status"] == "success" - # 两次 /sid 应返回相同的会话信息 - assert resp1["response"] == resp2["response"] - + """会话操作：创建、重命名、列表、重置、历史、删除、切换""" -# ============================================================ -# 第五层：插件系统端到端测试 -# ============================================================ - - -class TestPluginSystem: - """插件系统端到端测试 - - 验证链路：消息 → Pipeline → 插件路由 → 插件执行 → 响应 - """ - - def test_plugin_list(self): - """/plugin ls 返回已加载插件列表""" - resp = send_message("/plugin ls") + def test_full_lifecycle(self): + """new → rename → ls → reset → history → del""" + resp = send_message("/new") assert resp["status"] == "success" - text = resp["response"] - assert "插件" in text or "plugin" in text.lower() - # 至少有内置插件 - assert "astrbot" in text.lower() or "builtin" in text.lower() - def test_plugin_help(self): - """/plugin help 返回插件帮助""" - resp = send_message("/plugin help") + resp = send_message("/rename e2e_lifecycle_test") assert resp["status"] == "success" - def test_plugin_help_specific(self): - """/plugin help 返回特定插件帮助""" - # 先获取插件列表找到一个可用插件 - resp_ls = send_message("/plugin ls") - assert resp_ls["status"] == "success" - - # builtin_commands 一定存在 - resp_help = send_message("/plugin help builtin_commands") - assert resp_help["status"] == "success" - text = resp_help["response"] - assert "指令" in text or "帮助" in text or "help" in text.lower() - - -# ============================================================ -# 第六层：Provider/Model 管理端到端测试 -# ============================================================ - + resp = send_message("/ls") + assert resp["status"] == "success" + assert "e2e_lifecycle_test" in resp["response"] -class TestProviderModel: - """Provider/Model 管理端到端测试 + resp = send_message("/reset") + assert resp["status"] == "success" - 验证链路：/provider, /model, /key 命令的完整管道处理 - """ + resp = send_message("/history") + assert resp["status"] == "success" - def test_model_list(self): - """/model 返回可用模型列表""" - resp = send_message("/model") + resp = send_message("/del") assert resp["status"] == "success" - text = resp["response"] - # 应该包含模型列表或图片 - assert text or resp["images"] - def test_key_list(self): - """/key 返回 Key 信息""" - resp = send_message("/key") + def test_switch(self): + """new → switch → del""" + send_message("/new") + resp = send_message("/switch 1") assert resp["status"] == "success" - text = resp["response"] - assert "Key" in text or "key" in text.lower() or "当前" in text + assert "切换" in resp["response"] + send_message("/del") # ============================================================ -# 第七层：日志子系统端到端测试 +# 第四层：日志子系统 +# +# 服务端调用：get_logs ×3 = 3 次 # ============================================================ class TestLogSubsystem: - """日志子系统端到端测试 - - 验证链路（Socket 模式）： - get_logs 请求 → SocketClientHandler._get_logs() - → 读取日志文件 → 过滤 → 返回 - - 验证链路（文件直读）： - _read_log_from_file() → 读取 data/logs/astrbot.log - """ + """日志获取、级别过滤、模式过滤""" - def test_get_logs_via_socket(self): - """通过 Socket 获取日志""" + def test_get_logs(self): resp = get_logs(lines=10) assert resp["status"] == "success" - # 应该返回一些日志内容 assert "response" in resp - def test_get_logs_with_level_filter(self): - """日志级别过滤""" + def test_level_filter(self): resp = get_logs(lines=50, level="INFO") assert resp["status"] == "success" text = resp.get("response", "") - # 如果有日志，每行都应包含 [INFO] - if text.strip(): - for line in text.strip().split("\n"): - if line.strip(): - assert "[INFO]" in line, f"过滤后仍有非 INFO 日志: {line}" - - def test_get_logs_with_pattern(self): - """日志模式过滤""" + for line in text.strip().split("\n"): + if line.strip(): + assert "[INFO]" in line, f"非 INFO 日志: {line}" + + def test_pattern_filter(self): resp = get_logs(lines=50, pattern="CLI") assert resp["status"] == "success" text = resp.get("response", "") - if text.strip(): - for line in text.strip().split("\n"): - if line.strip(): - assert "CLI" in line or "cli" in line - - -# ============================================================ -# 第八层：客户端输出模块测试 -# ============================================================ - - -class TestClientOutput: - """客户端输出格式化端到端测试 - - 验证 format_response 正确解析真实服务端响应 - """ - - def test_format_text_response(self): - """格式化纯文本响应""" - resp = send_message("/help") - formatted = format_response(resp) - assert len(formatted) > 0 - assert "help" in formatted.lower() or "指令" in formatted - - @pytest.mark.timeout(_LLM_TIMEOUT) - def test_format_image_response(self): - """格式化含图片的响应""" - resp = send_message("/provider", timeout=_LLM_TIMEOUT) - if resp.get("images"): - formatted = format_response(resp) - assert "图片" in formatted - - def test_format_error_response(self): - """错误响应格式化为空字符串""" - fake_error = {"status": "error", "error": "test"} - formatted = format_response(fake_error) - assert formatted == "" + for line in text.strip().split("\n"): + if line.strip(): + assert "CLI" in line or "cli" in line # ============================================================ -# 第九层：长链条场景测试 +# 第4.5层：函数工具管理（通过 socket action 协议，2 次服务端调用） # ============================================================ -class TestLongChainScenarios: - """长链条场景端到端测试 - - 模拟真实用户操作序列，验证多步骤跨模块交互。 - """ - - def test_scenario_new_user_onboarding(self): - """场景：新用户首次使用 - - 链路：help → sid → plugin ls → model - """ - # 1. 查看帮助（带重试，前面测试可能导致服务端短暂繁忙） - resp = _send_with_retry("/help") - assert resp["status"] == "success" - assert "/help" in resp["response"] - - # 3. 获取会话信息 - resp = send_message("/sid") - assert resp["status"] == "success" - assert "cli" in resp["response"].lower() - - # 4. 查看插件 - resp = send_message("/plugin ls") - assert resp["status"] == "success" +class TestFunctionTools: + """测试 list_tools 和 call_tool socket action""" - # 5. 查看模型 - resp = send_message("/model") + def test_list_tools(self): + """列出所有注册的函数工具""" + resp = list_tools() assert resp["status"] == "success" + # tools 可能在 tools 字段或 response 字段 + tools = resp.get("tools", []) + if not tools: + import json - @pytest.mark.timeout(_LLM_TIMEOUT) - def test_scenario_conversation_workflow(self): - """场景：完整对话工作流 - - 链路：new → rename → ls → send msg → history → reset → del - """ - # 1. 创建新对话 - resp = send_message("/new") - assert resp["status"] == "success" + raw = resp.get("response", "") + if raw: + tools = json.loads(raw) + # 应该是列表类型 + assert isinstance(tools, list) + # 每个工具应有 name 字段 + for t in tools: + assert "name" in t - # 2. 重命名 - resp = send_message("/rename e2e_workflow_test") - assert resp["status"] == "success" + def test_call_nonexistent_tool(self): + """调用不存在的工具应返回错误""" + resp = call_tool("__nonexistent_tool_xyz__") + assert resp["status"] == "error" + assert "未找到" in resp.get("error", "") - # 3. 确认在列表中 - resp = send_message("/ls") - assert resp["status"] == "success" - assert "e2e_workflow_test" in resp["response"] - # 4. 发送消息（触发 LLM 管道） - resp = send_message("请回复OK", timeout=_LLM_TIMEOUT) - assert resp["status"] == "success" +# ============================================================ - # 5. 查看历史（应该有刚才的对话） - resp = send_message("/history") - assert resp["status"] == "success" - history_text = resp["response"] - assert ( - "OK" in history_text or "请回复" in history_text or "历史" in history_text - ) - # 6. 重置 - resp = send_message("/reset") - assert resp["status"] == "success" +class TestClientOutput: + """format_response 纯函数测试，使用 fake 数据""" + + def test_format_success(self): + fake_ok = { + "status": "success", + "response": "测试内容", + "images": [], + "request_id": "fake-id", + } + assert len(format_response(fake_ok)) > 0 + + def test_format_with_images(self): + fake_img = { + "status": "success", + "response": "", + "images": ["base64data"], + "request_id": "fake-id", + } + formatted = format_response(fake_img) + assert "图片" in formatted or len(formatted) > 0 + + def test_format_error(self): + fake_err = {"status": "error", "error": "test"} + assert format_response(fake_err) == "" - # 7. 删除 - resp = send_message("/del") - assert resp["status"] == "success" - def test_scenario_plugin_inspection(self): - """场景：逐一检查插件信息 +# ============================================================ +# 第六层：边界条件（每个 case 唯一，3 次服务端调用） +# ============================================================ - 链路：plugin ls → 解析插件名 → plugin help - """ - # 1. 获取插件列表 - resp = send_message("/plugin ls") - assert resp["status"] == "success" - # 2. 对 builtin_commands 查看帮助 - resp = send_message("/plugin help builtin_commands") - assert resp["status"] == "success" - assert "指令" in resp["response"] or "帮助" in resp["response"] - - def test_scenario_rapid_fire_commands(self): - """场景：快速连续发送多条命令 - - 验证服务端能正确处理串行请求，不混淆响应。 - """ - commands = ["/help", "/sid", "/ls", "/model", "/key"] - responses = [] - - for cmd in commands: - resp = send_message(cmd) - assert resp["status"] == "success", f"命令 {cmd} 失败: {resp}" - responses.append(resp) - - # 验证每个响应的 request_id 都不同 - request_ids = [r["request_id"] for r in responses] - assert len(set(request_ids)) == len(request_ids), "request_id 不唯一" - - # 验证响应内容合理（不混淆） - # /help 的响应应包含 "指令" - assert "指令" in responses[0]["response"] or "帮助" in responses[0]["response"] - # /sid 的响应应包含 "cli" - assert "cli" in responses[1]["response"].lower() - - @pytest.mark.timeout(_LLM_TIMEOUT) - def test_scenario_conversation_isolation(self): - """场景：对话切换后上下文隔离 - - 验证 /new 创建新对话后，/history 应该为空或不含前一个对话内容。 - """ - # 1. 创建新对话 - resp = send_message("/new") - assert resp["status"] == "success" +class TestEdgeCases: + """缺少参数、无效参数、不存在的命令""" - # 2. 发消息 - resp = send_message("isolation_marker_abc", timeout=_LLM_TIMEOUT) + def test_empty_command_args(self): + resp = send_message("/switch") assert resp["status"] == "success" - # 3. 创建另一个新对话 - resp = send_message("/new") + def test_invalid_switch_index(self): + resp = send_message("/switch 99999") assert resp["status"] == "success" - # 4. 查看历史（新对话应该没有 isolation_marker_abc） - resp = send_message("/history") + def test_unknown_slash_command(self): + resp = send_message("/nonexistent_cmd_xyz_123") assert resp["status"] == "success" - assert "isolation_marker_abc" not in resp["response"] - - # 清理：删除两个测试对话 - send_message("/del") - send_message("/switch 1") # 可能需要先切换 - # 找到并删除之前的对话 - resp_ls = send_message("/ls") - if "isolation_marker" in resp_ls.get("response", ""): - send_message("/del") # ============================================================ -# 第十层：错误处理与边界条件测试 +# 第七层：健壮性（测试行为而非命令内容） +# +# 用 /ls 做轻量探测（不与上方命令测试重复验证内容） +# 服务端调用：/ls ×9 = 9 次 # ============================================================ -class TestErrorHandling: - """错误处理与边界条件端到端测试""" - - @pytest.mark.timeout(_LLM_TIMEOUT) - def test_very_long_message(self): - """超长消息不导致崩溃""" - long_msg = "A" * 10000 - resp = send_message(long_msg, timeout=_LLM_TIMEOUT) - # 应该成功处理或返回合理错误，不能崩溃 - assert resp["status"] in ("success", "error") +class TestRobustness: + """并发稳定性和响应隔离（只验证机制，不验证命令内容）""" - @pytest.mark.timeout(_LLM_TIMEOUT) - def test_unicode_message(self): - """Unicode 消息正确处理""" - resp = send_message("你好世界 🌍 こんにちは мир", timeout=_LLM_TIMEOUT) - assert resp["status"] == "success" - - @pytest.mark.timeout(_LLM_TIMEOUT) - def test_special_characters(self): - """特殊字符消息""" - resp = send_message('hello "world" <>&{}[]', timeout=_LLM_TIMEOUT) - assert resp["status"] == "success" - - def test_empty_command_args(self): - """/switch 无参数""" - resp = send_message("/switch") - assert resp["status"] == "success" - # 应该返回错误提示而不是崩溃 + def test_rapid_fire_no_mixing(self): + """4次快速请求，request_id 全部唯一""" + responses = [send_message("/ls") for _ in range(4)] + for r in responses: + assert r["status"] == "success" + ids = [r["request_id"] for r in responses] + assert len(set(ids)) == len(ids), "request_id 不唯一" - def test_invalid_switch_index(self): - """/switch 无效序号""" - resp = send_message("/switch 99999") - assert resp["status"] == "success" - # 应该返回错误提示 - - def test_concurrent_stability(self): - """多次快速请求稳定性（允许偶发失败但大多数应成功）""" - success_count = 0 - total = 5 - for i in range(total): - resp = send_message("/help") - if resp["status"] == "success": - success_count += 1 - # 至少 80% 成功 - assert success_count >= total * 0.8, ( - f"并发稳定性不足: {success_count}/{total} 成功" - ) + def test_stability(self): + """5次请求至少4次成功""" + success = sum(1 for _ in range(5) if send_message("/ls")["status"] == "success") + assert success >= 4, f"稳定性不足: {success}/5" From 441779c568621cbbd2cb1a3c9f4916508371098a Mon Sep 17 00:00:00 2001 From: YukiRa1n <167516635+YukiRa1n@users.noreply.github.com> Date: Thu, 19 Feb 2026 23:39:37 +0800 Subject: [PATCH 35/39] perf: lazy init logger in astrbot/__init__.py to avoid core loading on CLI client MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit 使用 PEP 562 __getattr__ 延迟初始化 logger，CLI 客户端不再触发 astrbot/core 全量初始化，同时移除 __main__.py 中冗余的日志抑制代码。 --- astrbot/__init__.py | 10 ++++++++-- astrbot/cli/client/__main__.py | 25 +++++-------------------- 2 files changed, 13 insertions(+), 22 deletions(-) diff --git a/astrbot/__init__.py b/astrbot/__init__.py index 73d64f303f..a13ca37a20 100644 --- a/astrbot/__init__.py +++ b/astrbot/__init__.py @@ -1,3 +1,9 @@ -from .core.log import LogManager +def __getattr__(name: str): + """延迟初始化 logger，避免 CLI 客户端导入时触发 core 全量初始化""" + if name == "logger": + from .core.log import LogManager -logger = LogManager.GetLogger(log_name="astrbot") + _logger = LogManager.GetLogger(log_name="astrbot") + globals()["logger"] = _logger + return _logger + raise AttributeError(f"module {__name__!r} has no attribute {name!r}") diff --git a/astrbot/cli/client/__main__.py b/astrbot/cli/client/__main__.py index 579f013406..86dd7d816b 100644 --- a/astrbot/cli/client/__main__.py +++ b/astrbot/cli/client/__main__.py @@ -10,26 +10,11 @@ echo "你好" | astr """ -# 抑制框架导入时的日志输出（必须在所有导入之前执行） -import logging - -# 禁用所有 astrbot 相关日志 -logging.getLogger("astrbot").setLevel(logging.CRITICAL + 1) -logging.getLogger("astrbot.core").setLevel(logging.CRITICAL + 1) -# 禁用根日志记录器的控制台输出 -root = logging.getLogger() -root.setLevel(logging.CRITICAL + 1) -# 移除可能存在的控制台处理器 -for handler in root.handlers[:]: - if isinstance(handler, logging.StreamHandler): - root.removeHandler(handler) - -import io # noqa: E402 -import sys # noqa: E402 - -import click # noqa: E402 - -# 仅使用标准库导入，不导入astrbot框架 +import io +import sys + +import click + # Windows UTF-8 输出支持（仅在非测试环境下替换，避免与 pytest capture 冲突） if sys.platform == "win32" and "pytest" not in sys.modules: sys.stdout = io.TextIOWrapper(sys.stdout.buffer, encoding="utf-8", errors="replace") From a8f5e86b0cf79afc871fdbd5531c8d4200a2c1ac Mon Sep 17 00:00:00 2001 From: YukiRa1n <167516635+YukiRa1n@users.noreply.github.com> Date: Wed, 25 Feb 2026 00:54:28 +0800 Subject: [PATCH 36/39] style: ruff format --- astrbot/core/agent/handoff.py | 1 - astrbot/dashboard/routes/platform.py | 6 +++++- 2 files changed, 5 insertions(+), 2 deletions(-) diff --git a/astrbot/core/agent/handoff.py b/astrbot/core/agent/handoff.py index 8475009d3f..9510f76cb0 100644 --- a/astrbot/core/agent/handoff.py +++ b/astrbot/core/agent/handoff.py @@ -15,7 +15,6 @@ def __init__( tool_description: str | None = None, **kwargs, ) -> None: - # Avoid passing duplicate `description` to the FunctionTool dataclass. # Some call sites (e.g. SubAgentOrchestrator) pass `description` via kwargs # to override what the main agent sees, while we also compute a default diff --git a/astrbot/dashboard/routes/platform.py b/astrbot/dashboard/routes/platform.py index d4634c7c5f..487bad62e9 100644 --- a/astrbot/dashboard/routes/platform.py +++ b/astrbot/dashboard/routes/platform.py @@ -82,7 +82,11 @@ def _find_platform_by_uuid(self, webhook_uuid: str) -> Platform | None: """ for platform in self.platform_manager.platform_insts: config = platform.config - uuid_val = config.get("webhook_uuid") if isinstance(config, dict) else getattr(config, "webhook_uuid", None) + uuid_val = ( + config.get("webhook_uuid") + if isinstance(config, dict) + else getattr(config, "webhook_uuid", None) + ) if uuid_val == webhook_uuid: if platform.unified_webhook(): return platform From 08bac1e536568421b4959f304e9c21b891645533 Mon Sep 17 00:00:00 2001 From: YukiRa1n <167516635+YukiRa1n@users.noreply.github.com> Date: Wed, 25 Feb 2026 15:07:50 +0800 Subject: [PATCH 37/39] feat(cli): add cross-session browsing via astr session ls/convs/history MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit 通过 action-based socket 协议实现跨会话浏览，支持查看任意平台会话的对话列表和聊天记录。 - 新增 ConversationManager 全局单例访问 - socket_handler 添加 list_sessions/list_session_conversations/get_session_history action - connection.py 添加对应客户端请求方法 - 新建 session.py 命令组 (ls/convs/history) - 聊天记录以 You/AI 交替格式显示，图片用 [图片] 占位 --- astrbot/cli/client/__main__.py | 6 + astrbot/cli/client/commands/__init__.py | 4 + astrbot/cli/client/commands/session.py | 171 +++++++++ astrbot/cli/client/connection.py | 66 ++++ astrbot/core/conversation_mgr.py | 10 + .../platform/sources/cli/socket_handler.py | 239 +++++++++++++ tests/test_cli/test_client_commands.py | 198 ++++++++++ tests/test_cli/test_client_e2e.py | 97 +++++ tests/test_cli/test_session_actions.py | 338 ++++++++++++++++++ 9 files changed, 1129 insertions(+) create mode 100644 astrbot/cli/client/commands/session.py create mode 100644 tests/test_cli/test_session_actions.py diff --git a/astrbot/cli/client/__main__.py b/astrbot/cli/client/__main__.py index 86dd7d816b..0994eceeef 100644 --- a/astrbot/cli/client/__main__.py +++ b/astrbot/cli/client/__main__.py @@ -78,6 +78,12 @@ astr tool info 查看工具详细信息和参数 astr tool call [json] 调用工具，例: astr tool call my_func '{"k":"v"}' + [跨会话浏览] astr session <子命令> + astr session ls 列出所有会话（跨平台：QQ/TG/微信/CLI…） + astr session ls -P qq 按平台过滤（-q 搜索关键词） + astr session convs 查看该会话下的对话列表 + astr session history 查看聊天记录（-c 指定对话，默认当前） + [交互模式] astr interactive 进入 REPL 模式（支持命令历史） astr -i 同上（快捷方式） diff --git a/astrbot/cli/client/commands/__init__.py b/astrbot/cli/client/commands/__init__.py index d24965fed6..6a55873070 100644 --- a/astrbot/cli/client/commands/__init__.py +++ b/astrbot/cli/client/commands/__init__.py @@ -9,6 +9,7 @@ from .plugin import plugin from .provider import key, model, provider from .send import send +from .session import session from .tool import tool @@ -25,6 +26,9 @@ def register_commands(group): # 会话管理 group.add_command(conv) + # 跨会话浏览 + group.add_command(session) + # 插件管理 group.add_command(plugin) diff --git a/astrbot/cli/client/commands/session.py b/astrbot/cli/client/commands/session.py new file mode 100644 index 0000000000..3042a2fb79 --- /dev/null +++ b/astrbot/cli/client/commands/session.py @@ -0,0 +1,171 @@ +"""跨会话浏览命令组 - astr session""" + +import json +import sys + +import click + +from ..connection import ( + get_session_history, + list_session_conversations, + list_sessions, +) + + +@click.group(help="跨会话浏览 — 查看任意平台的会话和聊天记录 (ls/convs/history)") +def session() -> None: + """跨会话浏览命令组""" + + +@session.command(name="ls", help="列出所有会话（跨平台：QQ/TG/微信/CLI…）") +@click.option("--page", "-p", type=int, default=1, help="页码 (默认 1)") +@click.option("--size", "-s", type=int, default=20, help="每页数量 (默认 20)") +@click.option("--platform", "-P", type=str, default=None, help="按平台过滤") +@click.option("--search", "-q", type=str, default=None, help="搜索关键词") +@click.option("-j", "--json-output", "use_json", is_flag=True, help="输出原始 JSON") +def session_ls( + page: int, size: int, platform: str | None, search: str | None, use_json: bool +) -> None: + """列出所有会话""" + resp = list_sessions( + page=page, + page_size=size, + platform=platform, + search_query=search, + ) + + if resp.get("status") != "success": + click.echo(f"[ERROR] {resp.get('error', 'Unknown error')}", err=True) + sys.exit(1) + + if use_json: + click.echo(json.dumps(resp, ensure_ascii=False, indent=2)) + return + + sessions = resp.get("sessions", []) + if not sessions: + click.echo("没有找到会话。") + return + + click.echo(f"{'#':<4} {'会话 ID':<45} {'当前对话标题':<20} {'人设'}") + click.echo("-" * 90) + for i, s in enumerate(sessions, start=(page - 1) * size + 1): + sid = s.get("session_id", "?") + title = s.get("title") or "(无标题)" + persona = s.get("persona_name") or "-" + # 截断过长的字段 + if len(sid) > 43: + sid = sid[:40] + "..." + if len(title) > 18: + title = title[:15] + "..." + click.echo(f"{i:<4} {sid:<45} {title:<20} {persona}") + + total = resp.get("total", 0) + total_pages = resp.get("total_pages", 0) + click.echo(f"\n共 {total} 个会话，第 {page}/{total_pages} 页") + + +@session.command(name="convs", help="查看指定会话下的对话列表") +@click.argument("session_id") +@click.option("--page", "-p", type=int, default=1, help="页码 (默认 1)") +@click.option("--size", "-s", type=int, default=20, help="每页数量 (默认 20)") +@click.option("-j", "--json-output", "use_json", is_flag=True, help="输出原始 JSON") +def session_convs(session_id: str, page: int, size: int, use_json: bool) -> None: + """查看指定会话的对话列表""" + resp = list_session_conversations( + session_id=session_id, + page=page, + page_size=size, + ) + + if resp.get("status") != "success": + click.echo(f"[ERROR] {resp.get('error', 'Unknown error')}", err=True) + sys.exit(1) + + if use_json: + click.echo(json.dumps(resp, ensure_ascii=False, indent=2)) + return + + convs = resp.get("conversations", []) + if not convs: + click.echo(f"会话 {session_id} 没有对话。") + return + + click.echo(f"会话: {session_id}") + click.echo(f"当前对话: {resp.get('current_cid', '无')}") + click.echo("") + click.echo(f"{'#':<4} {'对话 ID':<38} {'标题':<20} {'Token':<8} {'当前'}") + click.echo("-" * 80) + for i, c in enumerate(convs, start=(page - 1) * size + 1): + cid = c.get("cid", "?") + title = c.get("title") or "(无标题)" + token = c.get("token_usage", 0) + is_curr = "*" if c.get("is_current") else "" + if len(title) > 18: + title = title[:15] + "..." + click.echo(f"{i:<4} {cid:<38} {title:<20} {token:<8} {is_curr}") + + total = resp.get("total", 0) + total_pages = resp.get("total_pages", 0) + click.echo(f"\n共 {total} 个对话，第 {page}/{total_pages} 页") + + +@session.command(name="history", help="查看聊天记录（用户/AI 交替显示）") +@click.argument("session_id") +@click.option( + "-c", "--conversation-id", type=str, default=None, help="对话 ID (默认当前对话)" +) +@click.option("--page", "-p", type=int, default=1, help="页码 (默认 1)") +@click.option("--size", "-s", type=int, default=10, help="每页数量 (默认 10)") +@click.option("-j", "--json-output", "use_json", is_flag=True, help="输出原始 JSON") +def session_history( + session_id: str, + conversation_id: str | None, + page: int, + size: int, + use_json: bool, +) -> None: + """查看指定会话的聊天记录""" + resp = get_session_history( + session_id=session_id, + conversation_id=conversation_id, + page=page, + page_size=size, + ) + + if resp.get("status") != "success": + click.echo(f"[ERROR] {resp.get('error', 'Unknown error')}", err=True) + sys.exit(1) + + if use_json: + click.echo(json.dumps(resp, ensure_ascii=False, indent=2)) + return + + _render_history(resp, session_id, page) + + +def _render_history(resp: dict, session_id: str, page: int) -> None: + """简洁地渲染聊天记录：用户/AI 交替显示。""" + history = resp.get("history", []) + total_pages = resp.get("total_pages", 0) + cid = resp.get("conversation_id") + + click.echo(f"会话: {session_id}") + click.echo(f"对话: {cid or '(无)'} 页码: {page}/{total_pages}") + click.echo("-" * 60) + + if not history: + click.echo("(无聊天记录)") + return + + for msg in history: + # 新格式：msg 是 {"role": "user"|"assistant", "text": "..."} + if isinstance(msg, dict): + role = msg.get("role", "?") + text = msg.get("text", "") + label = "You" if role == "user" else "AI" + click.echo(f"{label}: {text}") + else: + # 兼容旧格式（纯字符串） + click.echo(msg) + click.echo() diff --git a/astrbot/cli/client/connection.py b/astrbot/cli/client/connection.py index db1e83d3fc..1703985957 100644 --- a/astrbot/cli/client/connection.py +++ b/astrbot/cli/client/connection.py @@ -356,3 +356,69 @@ def call_tool( socket_path=socket_path, timeout=timeout, ) + + +def list_sessions( + page: int = 1, + page_size: int = 20, + platform: str | None = None, + search_query: str | None = None, + socket_path: str | None = None, + timeout: float = 30.0, +) -> dict: + """列出所有会话""" + fields: dict = {"page": page, "page_size": page_size} + if platform: + fields["platform"] = platform + if search_query: + fields["search_query"] = search_query + return _send_action_request( + "list_sessions", + extra_fields=fields, + socket_path=socket_path, + timeout=timeout, + ) + + +def list_session_conversations( + session_id: str, + page: int = 1, + page_size: int = 20, + socket_path: str | None = None, + timeout: float = 30.0, +) -> dict: + """列出指定会话的所有对话""" + return _send_action_request( + "list_session_conversations", + extra_fields={ + "session_id": session_id, + "page": page, + "page_size": page_size, + }, + socket_path=socket_path, + timeout=timeout, + ) + + +def get_session_history( + session_id: str, + conversation_id: str | None = None, + page: int = 1, + page_size: int = 10, + socket_path: str | None = None, + timeout: float = 30.0, +) -> dict: + """获取指定会话的聊天记录""" + fields: dict = { + "session_id": session_id, + "page": page, + "page_size": page_size, + } + if conversation_id: + fields["conversation_id"] = conversation_id + return _send_action_request( + "get_session_history", + extra_fields=fields, + socket_path=socket_path, + timeout=timeout, + ) diff --git a/astrbot/core/conversation_mgr.py b/astrbot/core/conversation_mgr.py index 6fcb3608c3..7400d41d71 100644 --- a/astrbot/core/conversation_mgr.py +++ b/astrbot/core/conversation_mgr.py @@ -12,11 +12,21 @@ from astrbot.core.db import BaseDatabase from astrbot.core.db.po import Conversation, ConversationV2 +# 模块级单例引用，供无法通过依赖注入获取实例的模块使用（如CLI适配器） +_global_instance: "ConversationManager | None" = None + + +def get_conversation_manager() -> "ConversationManager | None": + """获取全局 ConversationManager 实例""" + return _global_instance + class ConversationManager: """负责管理会话与 LLM 的对话，某个会话当前正在用哪个对话。""" def __init__(self, db_helper: BaseDatabase) -> None: + global _global_instance + _global_instance = self self.session_conversations: dict[str, str] = {} self.db = db_helper self.save_interval = 60 # 每 60 秒保存一次 diff --git a/astrbot/core/platform/sources/cli/socket_handler.py b/astrbot/core/platform/sources/cli/socket_handler.py index 0ba07915d3..3f7d5cfbf2 100644 --- a/astrbot/core/platform/sources/cli/socket_handler.py +++ b/astrbot/core/platform/sources/cli/socket_handler.py @@ -173,6 +173,12 @@ async def handle(self, client_socket) -> None: response = self._list_tools(request_id) elif action == "call_tool": response = await self._call_tool(request, request_id) + elif action == "list_sessions": + response = await self._list_sessions(request, request_id) + elif action == "list_session_conversations": + response = await self._list_session_conversations(request, request_id) + elif action == "get_session_history": + response = await self._get_session_history(request, request_id) else: message_text = request.get("message", "") response = await self._process_message(message_text, request_id) @@ -451,6 +457,239 @@ async def _call_tool(self, request: dict, request_id: str) -> str: request_id, ) + # ------------------------------------------------------------------ + # 跨会话浏览（CLI专属） + # ------------------------------------------------------------------ + + async def _list_sessions(self, request: dict, request_id: str) -> str: + """列出所有会话""" + from astrbot.core.conversation_mgr import get_conversation_manager + + conv_mgr = get_conversation_manager() + if conv_mgr is None: + return _build_error_response("ConversationManager 未初始化", request_id) + + try: + page = request.get("page", 1) + page_size = request.get("page_size", 20) + platform = request.get("platform") or None + search_query = request.get("search_query") or None + + sessions, total = await conv_mgr.db.get_session_conversations( + page=page, + page_size=page_size, + search_query=search_query, + platform=platform, + ) + + total_pages = (total + page_size - 1) // page_size if total > 0 else 0 + + return json.dumps( + { + "status": "success", + "sessions": sessions, + "total": total, + "page": page, + "page_size": page_size, + "total_pages": total_pages, + "response": f"共 {total} 个会话，第 {page}/{total_pages} 页", + "images": [], + "request_id": request_id, + }, + ensure_ascii=False, + ) + except Exception as e: + logger.exception("[CLI] Error listing sessions") + return _build_error_response(f"列出会话失败: {e}", request_id) + + async def _list_session_conversations(self, request: dict, request_id: str) -> str: + """列出指定会话的所有对话""" + from astrbot.core.conversation_mgr import get_conversation_manager + + conv_mgr = get_conversation_manager() + if conv_mgr is None: + return _build_error_response("ConversationManager 未初始化", request_id) + + session_id = request.get("session_id", "") + if not session_id: + return _build_error_response("缺少 session_id 参数", request_id) + + try: + page = request.get("page", 1) + page_size = request.get("page_size", 20) + + conversations = await conv_mgr.get_conversations( + unified_msg_origin=session_id, + ) + + # 手动分页 + total = len(conversations) + total_pages = (total + page_size - 1) // page_size if total > 0 else 0 + start = (page - 1) * page_size + end = start + page_size + paged = conversations[start:end] + + convs_data = [] + curr_cid = await conv_mgr.get_curr_conversation_id(session_id) + for conv in paged: + convs_data.append( + { + "cid": conv.cid, + "title": conv.title or "(无标题)", + "persona_id": conv.persona_id, + "created_at": conv.created_at, + "updated_at": conv.updated_at, + "token_usage": conv.token_usage, + "is_current": conv.cid == curr_cid, + } + ) + + return json.dumps( + { + "status": "success", + "conversations": convs_data, + "total": total, + "page": page, + "page_size": page_size, + "total_pages": total_pages, + "current_cid": curr_cid, + "response": f"会话 {session_id} 共 {total} 个对话，第 {page}/{total_pages} 页", + "images": [], + "request_id": request_id, + }, + ensure_ascii=False, + ) + except Exception as e: + logger.exception("[CLI] Error listing session conversations") + return _build_error_response(f"列出会话对话失败: {e}", request_id) + + async def _get_session_history(self, request: dict, request_id: str) -> str: + """获取指定会话的聊天记录""" + from astrbot.core.conversation_mgr import get_conversation_manager + + conv_mgr = get_conversation_manager() + if conv_mgr is None: + return _build_error_response("ConversationManager 未初始化", request_id) + + session_id = request.get("session_id", "") + if not session_id: + return _build_error_response("缺少 session_id 参数", request_id) + + try: + conversation_id = request.get("conversation_id") or None + page = request.get("page", 1) + page_size = request.get("page_size", 10) + + # 如果未指定 conversation_id，获取当前对话 + if not conversation_id: + conversation_id = await conv_mgr.get_curr_conversation_id(session_id) + + if not conversation_id: + return json.dumps( + { + "status": "success", + "history": [], + "total_pages": 0, + "page": page, + "conversation_id": None, + "response": f"会话 {session_id} 没有活跃的对话", + "images": [], + "request_id": request_id, + }, + ensure_ascii=False, + ) + + conversation = await conv_mgr.get_conversation(session_id, conversation_id) + if not conversation: + return json.dumps( + { + "status": "success", + "history": [], + "total_pages": 0, + "page": page, + "conversation_id": conversation_id, + "session_id": session_id, + "response": "(无记录)", + "images": [], + "request_id": request_id, + }, + ensure_ascii=False, + ) + + raw_history = json.loads(conversation.history) + + # 构建简洁的消息对列表，每对是 {"role": ..., "text": ...} + messages = [] + for record in raw_history: + role = record.get("role", "") + if role not in ("user", "assistant"): + continue + text = _extract_content_text(record) + messages.append({"role": role, "text": text}) + + # 分页（按消息条数） + total = len(messages) + total_pages = (total + page_size - 1) // page_size if total > 0 else 0 + start = (page - 1) * page_size + end = start + page_size + paged = messages[start:end] + + return json.dumps( + { + "status": "success", + "history": paged, + "total": total, + "total_pages": total_pages, + "page": page, + "conversation_id": conversation_id, + "session_id": session_id, + "response": "", + "images": [], + "request_id": request_id, + }, + ensure_ascii=False, + ) + except Exception as e: + logger.exception("[CLI] Error getting session history") + return _build_error_response(f"获取聊天记录失败: {e}", request_id) + + +def _extract_content_text(record: dict) -> str: + """从 OpenAI 格式的消息记录中提取纯文本，图片用 [图片] 占位。""" + content = record.get("content") + + # content 是字符串（最常见情况） + if isinstance(content, str): + return content + + # content 是 list（多部分内容，可能含图片） + if isinstance(content, list): + parts = [] + for part in content: + if isinstance(part, dict): + part_type = part.get("type", "") + if part_type == "text": + parts.append(part.get("text", "")) + elif part_type in ("image_url", "image"): + parts.append("[图片]") + else: + parts.append(f"[{part_type}]") + elif isinstance(part, str): + parts.append(part) + return " ".join(parts) if parts else "" + + # content 为 None（tool_calls 等情况） + if content is None: + if "tool_calls" in record: + names = [] + for tc in record.get("tool_calls", []): + fn = tc.get("function", {}) + names.append(fn.get("name", "?")) + return f"[调用工具: {', '.join(names)}]" + return "" + + return str(content) + # ------------------------------------------------------------------ # Socket模式处理器 diff --git a/tests/test_cli/test_client_commands.py b/tests/test_cli/test_client_commands.py index 21d98d3094..bef31fb8e1 100644 --- a/tests/test_cli/test_client_commands.py +++ b/tests/test_cli/test_client_commands.py @@ -557,3 +557,201 @@ def test_interactive_flag(self, mock_send): assert result.exit_code == 0 assert "再见" in result.output + + +class TestSessionCommand: + """session 命令组测试""" + + @patch("astrbot.cli.client.commands.session.list_sessions") + def test_session_ls(self, mock_list): + """列出所有会话""" + mock_list.return_value = { + "status": "success", + "sessions": [ + { + "session_id": "cli:FriendMessage:cli_session", + "conversation_id": "conv-123", + "title": "测试对话", + "persona_id": None, + "persona_name": None, + } + ], + "total": 1, + "page": 1, + "page_size": 20, + "total_pages": 1, + "response": "共 1 个会话", + } + runner = CliRunner() + result = runner.invoke(main, ["session", "ls"]) + + assert result.exit_code == 0 + assert "cli_session" in result.output + mock_list.assert_called_once() + + @patch("astrbot.cli.client.commands.session.list_sessions") + def test_session_ls_with_platform(self, mock_list): + """按平台过滤会话""" + mock_list.return_value = { + "status": "success", + "sessions": [], + "total": 0, + "page": 1, + "page_size": 20, + "total_pages": 0, + "response": "共 0 个会话", + } + runner = CliRunner() + result = runner.invoke(main, ["session", "ls", "-P", "qq"]) + + assert result.exit_code == 0 + mock_list.assert_called_once_with( + page=1, page_size=20, platform="qq", search_query=None + ) + + @patch("astrbot.cli.client.commands.session.list_sessions") + def test_session_ls_json(self, mock_list): + """JSON 输出""" + mock_list.return_value = { + "status": "success", + "sessions": [], + "total": 0, + "page": 1, + "page_size": 20, + "total_pages": 0, + "response": "共 0 个会话", + } + runner = CliRunner() + result = runner.invoke(main, ["session", "ls", "-j"]) + + assert result.exit_code == 0 + output = json.loads(result.output) + assert output["status"] == "success" + + @patch("astrbot.cli.client.commands.session.list_sessions") + def test_session_ls_error(self, mock_list): + """错误响应""" + mock_list.return_value = {"status": "error", "error": "未初始化"} + runner = CliRunner() + result = runner.invoke(main, ["session", "ls"]) + + assert result.exit_code == 1 + + @patch("astrbot.cli.client.commands.session.list_session_conversations") + def test_session_convs(self, mock_convs): + """查看指定会话的对话列表""" + mock_convs.return_value = { + "status": "success", + "conversations": [ + { + "cid": "conv-abc", + "title": "测试对话", + "persona_id": None, + "created_at": 1700000000, + "updated_at": 1700000000, + "token_usage": 100, + "is_current": True, + } + ], + "total": 1, + "page": 1, + "page_size": 20, + "total_pages": 1, + "current_cid": "conv-abc", + "response": "共 1 个对话", + } + runner = CliRunner() + result = runner.invoke( + main, ["session", "convs", "cli:FriendMessage:cli_session"] + ) + + assert result.exit_code == 0 + assert "conv-abc" in result.output + assert "测试对话" in result.output + + @patch("astrbot.cli.client.commands.session.list_session_conversations") + def test_session_convs_json(self, mock_convs): + """对话列表 JSON 输出""" + mock_convs.return_value = { + "status": "success", + "conversations": [], + "total": 0, + "page": 1, + "page_size": 20, + "total_pages": 0, + "current_cid": None, + "response": "共 0 个对话", + } + runner = CliRunner() + result = runner.invoke(main, ["session", "convs", "test_session", "-j"]) + + assert result.exit_code == 0 + output = json.loads(result.output) + assert output["status"] == "success" + + @patch("astrbot.cli.client.commands.session.get_session_history") + def test_session_history(self, mock_history): + """查看指定会话的聊天记录""" + mock_history.return_value = { + "status": "success", + "history": [ + {"role": "user", "text": "你好"}, + {"role": "assistant", "text": "你好！"}, + ], + "total_pages": 1, + "page": 1, + "conversation_id": "conv-abc", + "session_id": "cli:FriendMessage:cli_session", + "response": "", + } + runner = CliRunner() + result = runner.invoke( + main, ["session", "history", "cli:FriendMessage:cli_session"] + ) + + assert result.exit_code == 0 + assert "You: 你好" in result.output + assert "AI: 你好！" in result.output + + @patch("astrbot.cli.client.commands.session.get_session_history") + def test_session_history_with_cid(self, mock_history): + """指定对话 ID 查看聊天记录""" + mock_history.return_value = { + "status": "success", + "history": [], + "total_pages": 0, + "page": 1, + "conversation_id": "conv-xyz", + "session_id": "test_session", + "response": "(无记录)", + } + runner = CliRunner() + result = runner.invoke( + main, ["session", "history", "test_session", "-c", "conv-xyz"] + ) + + assert result.exit_code == 0 + mock_history.assert_called_once_with( + session_id="test_session", + conversation_id="conv-xyz", + page=1, + page_size=10, + ) + + @patch("astrbot.cli.client.commands.session.list_sessions") + def test_session_ls_empty(self, mock_list): + """空会话列表""" + mock_list.return_value = { + "status": "success", + "sessions": [], + "total": 0, + "page": 1, + "page_size": 20, + "total_pages": 0, + "response": "共 0 个会话", + } + runner = CliRunner() + result = runner.invoke(main, ["session", "ls"]) + + assert result.exit_code == 0 + assert "没有找到会话" in result.output diff --git a/tests/test_cli/test_client_e2e.py b/tests/test_cli/test_client_e2e.py index 98d70f17dd..2a2db8d989 100644 --- a/tests/test_cli/test_client_e2e.py +++ b/tests/test_cli/test_client_e2e.py @@ -21,6 +21,9 @@ call_tool, get_data_path, get_logs, + get_session_history, + list_session_conversations, + list_sessions, list_tools, load_auth_token, load_connection_info, @@ -241,6 +244,100 @@ def test_call_nonexistent_tool(self): assert "未找到" in resp.get("error", "") +# ============================================================ +# 第5层：跨会话浏览（通过 socket action 协议） +# +# 服务端调用：list_sessions ×2, list_session_conversations ×1, +# get_session_history ×2 = 5 次 +# ============================================================ + + +class TestCrossSessionBrowse: + """跨会话浏览功能端到端测试""" + + def test_list_sessions(self): + """列出所有会话 — 响应结构完整""" + resp = list_sessions() + assert resp["status"] == "success" + assert "sessions" in resp + assert isinstance(resp["sessions"], list) + assert "total" in resp + assert isinstance(resp["total"], int) + assert "total_pages" in resp + # 至少应有 CLI 管理员会话 + if resp["total"] > 0: + s = resp["sessions"][0] + assert "session_id" in s + assert "conversation_id" in s + + def test_list_sessions_pagination(self): + """会话列表分页参数正确回传""" + resp = list_sessions(page=1, page_size=5) + assert resp["status"] == "success" + assert resp["page"] == 1 + assert resp["page_size"] == 5 + assert "total_pages" in resp + + def test_list_sessions_platform_filter(self): + """按平台过滤 — 不崩溃，结果与总数一致""" + resp = list_sessions(platform="cli") + assert resp["status"] == "success" + for s in resp["sessions"]: + assert s["session_id"].startswith("cli:") + + def test_list_sessions_search(self): + """搜索过滤 — 不崩溃""" + resp = list_sessions(search_query="cli_session") + assert resp["status"] == "success" + + def test_list_session_conversations(self): + """列出 CLI 管理员会话的对话列表""" + resp = list_session_conversations("cli:FriendMessage:cli_session") + assert resp["status"] == "success" + assert "conversations" in resp + assert isinstance(resp["conversations"], list) + assert "current_cid" in resp + # 每个对话应有 cid/title/is_current + for c in resp["conversations"]: + assert "cid" in c + assert "title" in c + assert "is_current" in c + + def test_list_session_conversations_empty(self): + """不存在的会话 — 返回空对话列表，不报错""" + resp = list_session_conversations("nonexistent:FriendMessage:no_one") + assert resp["status"] == "success" + assert resp["conversations"] == [] + + def test_get_session_history_admin(self): + """获取管理员 CLI 会话的聊天记录 — 新格式验证""" + resp = get_session_history("cli:FriendMessage:cli_session") + assert resp["status"] == "success" + assert "history" in resp + assert isinstance(resp["history"], list) + assert "total_pages" in resp + assert "total" in resp + # 验证消息格式（每条是 dict 含 role/text） + for msg in resp["history"]: + assert isinstance(msg, dict) + assert "role" in msg + assert msg["role"] in ("user", "assistant") + assert "text" in msg + + def test_get_session_history_pagination(self): + """聊天记录分页""" + resp = get_session_history("cli:FriendMessage:cli_session", page=1, page_size=2) + assert resp["status"] == "success" + assert resp["page"] == 1 + assert len(resp["history"]) <= 2 + + def test_get_session_history_nonexistent(self): + """获取不存在会话的聊天记录（应返回空记录）""" + resp = get_session_history("nonexistent:FriendMessage:no_session") + assert resp["status"] == "success" + assert resp["history"] == [] + + # ============================================================ diff --git a/tests/test_cli/test_session_actions.py b/tests/test_cli/test_session_actions.py new file mode 100644 index 0000000000..86e9fe5bb1 --- /dev/null +++ b/tests/test_cli/test_session_actions.py @@ -0,0 +1,338 @@ +"""socket_handler 跨会话浏览 action 单元测试 + +测试 SocketClientHandler 中的 _list_sessions、_list_session_conversations、 +_get_session_history 三个方法。使用 mock 替代真实的 ConversationManager。 +""" + +import json +from unittest.mock import AsyncMock, MagicMock, patch + +import pytest + + +def _make_handler(): + """创建最小化的 SocketClientHandler 用于测试""" + from astrbot.core.platform.sources.cli.socket_handler import ( + SocketClientHandler, + ) + + handler = SocketClientHandler( + token_manager=MagicMock(), + message_converter=MagicMock(), + session_manager=MagicMock(), + platform_meta=MagicMock(), + output_queue=MagicMock(), + event_committer=MagicMock(), + ) + return handler + + +class TestListSessions: + """_list_sessions 方法测试""" + + @pytest.mark.asyncio + @patch("astrbot.core.conversation_mgr.get_conversation_manager") + async def test_list_sessions_success(self, mock_get_mgr): + handler = _make_handler() + mock_mgr = MagicMock() + mock_mgr.db.get_session_conversations = AsyncMock( + return_value=( + [ + { + "session_id": "cli:FriendMessage:cli_session", + "conversation_id": "conv-1", + "title": "测试", + "persona_id": None, + "persona_name": None, + } + ], + 1, + ) + ) + mock_get_mgr.return_value = mock_mgr + + result = await handler._list_sessions({"page": 1, "page_size": 20}, "req-1") + data = json.loads(result) + + assert data["status"] == "success" + assert len(data["sessions"]) == 1 + assert data["total"] == 1 + assert data["sessions"][0]["session_id"] == "cli:FriendMessage:cli_session" + + @pytest.mark.asyncio + @patch("astrbot.core.conversation_mgr.get_conversation_manager") + async def test_list_sessions_with_platform(self, mock_get_mgr): + handler = _make_handler() + mock_mgr = MagicMock() + mock_mgr.db.get_session_conversations = AsyncMock(return_value=([], 0)) + mock_get_mgr.return_value = mock_mgr + + result = await handler._list_sessions( + {"page": 1, "page_size": 10, "platform": "qq"}, "req-2" + ) + data = json.loads(result) + + assert data["status"] == "success" + assert data["sessions"] == [] + assert data["total"] == 0 + mock_mgr.db.get_session_conversations.assert_called_once_with( + page=1, page_size=10, search_query=None, platform="qq" + ) + + @pytest.mark.asyncio + @patch("astrbot.core.conversation_mgr.get_conversation_manager") + async def test_list_sessions_not_initialized(self, mock_get_mgr): + handler = _make_handler() + mock_get_mgr.return_value = None + + result = await handler._list_sessions({}, "req-3") + data = json.loads(result) + + assert data["status"] == "error" + assert "未初始化" in data["error"] + + +class TestListSessionConversations: + """_list_session_conversations 方法测试""" + + @pytest.mark.asyncio + @patch("astrbot.core.conversation_mgr.get_conversation_manager") + async def test_list_convs_success(self, mock_get_mgr): + handler = _make_handler() + mock_mgr = MagicMock() + + # Mock conversation objects + mock_conv = MagicMock() + mock_conv.cid = "conv-abc" + mock_conv.title = "测试对话" + mock_conv.persona_id = None + mock_conv.created_at = 1700000000 + mock_conv.updated_at = 1700000000 + mock_conv.token_usage = 150 + + mock_mgr.get_conversations = AsyncMock(return_value=[mock_conv]) + mock_mgr.get_curr_conversation_id = AsyncMock(return_value="conv-abc") + mock_get_mgr.return_value = mock_mgr + + result = await handler._list_session_conversations( + {"session_id": "cli:FriendMessage:cli_session", "page": 1, "page_size": 20}, + "req-4", + ) + data = json.loads(result) + + assert data["status"] == "success" + assert len(data["conversations"]) == 1 + assert data["conversations"][0]["cid"] == "conv-abc" + assert data["conversations"][0]["is_current"] is True + assert data["current_cid"] == "conv-abc" + + @pytest.mark.asyncio + @patch("astrbot.core.conversation_mgr.get_conversation_manager") + async def test_list_convs_missing_session_id(self, mock_get_mgr): + handler = _make_handler() + mock_get_mgr.return_value = MagicMock() + + result = await handler._list_session_conversations({"page": 1}, "req-5") + data = json.loads(result) + + assert data["status"] == "error" + assert "session_id" in data["error"] + + @pytest.mark.asyncio + @patch("astrbot.core.conversation_mgr.get_conversation_manager") + async def test_list_convs_pagination(self, mock_get_mgr): + handler = _make_handler() + mock_mgr = MagicMock() + + # Create 3 mock conversations + convs = [] + for i in range(3): + c = MagicMock() + c.cid = f"conv-{i}" + c.title = f"对话 {i}" + c.persona_id = None + c.created_at = 1700000000 + c.updated_at = 1700000000 + c.token_usage = 0 + convs.append(c) + + mock_mgr.get_conversations = AsyncMock(return_value=convs) + mock_mgr.get_curr_conversation_id = AsyncMock(return_value="conv-0") + mock_get_mgr.return_value = mock_mgr + + # Page 1 with size 2 + result = await handler._list_session_conversations( + {"session_id": "test", "page": 1, "page_size": 2}, "req-6" + ) + data = json.loads(result) + + assert data["total"] == 3 + assert data["total_pages"] == 2 + assert len(data["conversations"]) == 2 + + +class TestGetSessionHistory: + """_get_session_history 方法测试""" + + @pytest.mark.asyncio + @patch("astrbot.core.conversation_mgr.get_conversation_manager") + async def test_get_history_success(self, mock_get_mgr): + handler = _make_handler() + mock_mgr = MagicMock() + mock_mgr.get_curr_conversation_id = AsyncMock(return_value="conv-abc") + + # Mock conversation with raw history + mock_conv = MagicMock() + mock_conv.history = json.dumps( + [ + {"role": "user", "content": "你好"}, + {"role": "assistant", "content": "你好！"}, + ] + ) + mock_mgr.get_conversation = AsyncMock(return_value=mock_conv) + mock_get_mgr.return_value = mock_mgr + + result = await handler._get_session_history( + {"session_id": "cli:FriendMessage:cli_session", "page": 1}, + "req-7", + ) + data = json.loads(result) + + assert data["status"] == "success" + assert len(data["history"]) == 2 + assert data["history"][0]["role"] == "user" + assert data["history"][0]["text"] == "你好" + assert data["history"][1]["role"] == "assistant" + assert data["history"][1]["text"] == "你好！" + assert data["conversation_id"] == "conv-abc" + + @pytest.mark.asyncio + @patch("astrbot.core.conversation_mgr.get_conversation_manager") + async def test_get_history_with_image(self, mock_get_mgr): + """图片内容应被替换为 [图片]""" + handler = _make_handler() + mock_mgr = MagicMock() + + mock_conv = MagicMock() + mock_conv.history = json.dumps( + [ + { + "role": "user", + "content": [ + {"type": "text", "text": "看这张图"}, + {"type": "image_url", "image_url": {"url": "http://..."}}, + ], + }, + {"role": "assistant", "content": "这是一只猫"}, + ] + ) + mock_mgr.get_conversation = AsyncMock(return_value=mock_conv) + mock_get_mgr.return_value = mock_mgr + + result = await handler._get_session_history( + {"session_id": "test", "conversation_id": "conv-img", "page": 1}, + "req-img", + ) + data = json.loads(result) + + assert data["status"] == "success" + assert "[图片]" in data["history"][0]["text"] + assert "看这张图" in data["history"][0]["text"] + + @pytest.mark.asyncio + @patch("astrbot.core.conversation_mgr.get_conversation_manager") + async def test_get_history_with_tool_calls(self, mock_get_mgr): + """tool_calls 应被替换为 [调用工具: name]""" + handler = _make_handler() + mock_mgr = MagicMock() + + mock_conv = MagicMock() + mock_conv.history = json.dumps( + [ + {"role": "user", "content": "查天气"}, + { + "role": "assistant", + "content": None, + "tool_calls": [ + {"function": {"name": "get_weather", "arguments": "{}"}} + ], + }, + ] + ) + mock_mgr.get_conversation = AsyncMock(return_value=mock_conv) + mock_get_mgr.return_value = mock_mgr + + result = await handler._get_session_history( + {"session_id": "test", "conversation_id": "conv-tc", "page": 1}, + "req-tc", + ) + data = json.loads(result) + + assert data["status"] == "success" + assert "[调用工具: get_weather]" in data["history"][1]["text"] + + @pytest.mark.asyncio + @patch("astrbot.core.conversation_mgr.get_conversation_manager") + async def test_get_history_with_conv_id(self, mock_get_mgr): + handler = _make_handler() + mock_mgr = MagicMock() + + mock_conv = MagicMock() + mock_conv.history = json.dumps([{"role": "user", "content": "test"}]) + mock_mgr.get_conversation = AsyncMock(return_value=mock_conv) + mock_get_mgr.return_value = mock_mgr + + result = await handler._get_session_history( + { + "session_id": "test_session", + "conversation_id": "conv-xyz", + "page": 1, + }, + "req-8", + ) + data = json.loads(result) + + assert data["status"] == "success" + assert data["conversation_id"] == "conv-xyz" + mock_mgr.get_conversation.assert_called_once_with("test_session", "conv-xyz") + + @pytest.mark.asyncio + @patch("astrbot.core.conversation_mgr.get_conversation_manager") + async def test_get_history_no_active_conversation(self, mock_get_mgr): + handler = _make_handler() + mock_mgr = MagicMock() + mock_mgr.get_curr_conversation_id = AsyncMock(return_value=None) + mock_get_mgr.return_value = mock_mgr + + result = await handler._get_session_history( + {"session_id": "no_conv_session", "page": 1}, "req-9" + ) + data = json.loads(result) + + assert data["status"] == "success" + assert data["history"] == [] + assert "没有活跃的对话" in data["response"] + + @pytest.mark.asyncio + @patch("astrbot.core.conversation_mgr.get_conversation_manager") + async def test_get_history_missing_session_id(self, mock_get_mgr): + handler = _make_handler() + mock_get_mgr.return_value = MagicMock() + + result = await handler._get_session_history({"page": 1}, "req-10") + data = json.loads(result) + + assert data["status"] == "error" + assert "session_id" in data["error"] + + @pytest.mark.asyncio + @patch("astrbot.core.conversation_mgr.get_conversation_manager") + async def test_get_history_not_initialized(self, mock_get_mgr): + handler = _make_handler() + mock_get_mgr.return_value = None + + result = await handler._get_session_history({"session_id": "test"}, "req-11") + data = json.loads(result) + + assert data["status"] == "error" + assert "未初始化" in data["error"] From 59d4198d1c3a4db19992ec202d9548bb1c7a3d1e Mon Sep 17 00:00:00 2001 From: YukiRa1n <167516635+YukiRa1n@users.noreply.github.com> Date: Wed, 25 Feb 2026 16:00:30 +0800 Subject: [PATCH 38/39] refactor(cli): remove interactive/TTY mode MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit 删除交互模式相关代码，简化CLI适配器： - 移除 tty_handler.py 和 interactive.py - 移除 cli_adapter.py 中的 TTY 模式处理 - 移除客户端的 -i 快捷方式和 interactive 子命令 - 移除相关测试 --- astrbot/cli/client/__main__.py | 9 - astrbot/cli/client/commands/__init__.py | 4 - astrbot/cli/client/commands/interactive.py | 103 --------- .../core/platform/sources/cli/cli_adapter.py | 19 +- .../core/platform/sources/cli/tty_handler.py | 100 --------- tests/test_cli/test_client_commands.py | 15 -- tests/test_cli/test_client_interactive.py | 206 ------------------ 7 files changed, 1 insertion(+), 455 deletions(-) delete mode 100644 astrbot/cli/client/commands/interactive.py delete mode 100644 astrbot/core/platform/sources/cli/tty_handler.py delete mode 100644 tests/test_cli/test_client_interactive.py diff --git a/astrbot/cli/client/__main__.py b/astrbot/cli/client/__main__.py index 0994eceeef..2a2a60b51a 100644 --- a/astrbot/cli/client/__main__.py +++ b/astrbot/cli/client/__main__.py @@ -84,10 +84,6 @@ astr session convs 查看该会话下的对话列表 astr session history 查看聊天记录（-c 指定对话，默认当前） - [交互模式] - astr interactive 进入 REPL 模式（支持命令历史） - astr -i 同上（快捷方式） - [批量执行] astr batch 从文件逐行读取并执行命令 （# 开头为注释，空行跳过） @@ -112,8 +108,6 @@ def format_epilog(self, ctx: click.Context, formatter: click.HelpFormatter) -> N _send_opts = {"-j", "--json", "-t", "--timeout", "-s", "--socket"} # --log 旧用法映射到 log 子命令 _log_flag = {"--log"} - # -i 快捷方式映射到 interactive 子命令 - _interactive_flag = {"-i"} def parse_args(self, ctx: click.Context, args: list[str]) -> list[str]: if args: @@ -121,9 +115,6 @@ def parse_args(self, ctx: click.Context, args: list[str]) -> list[str]: if first in self._log_flag: # astr --log ... → astr log ... args = ["log"] + args[1:] - elif first in self._interactive_flag: - # astr -i → astr interactive - args = ["interactive"] + args[1:] elif first not in self.commands: if not first.startswith("-") or first in self._send_opts: # astr 你好 / astr -j "你好" → astr send ... diff --git a/astrbot/cli/client/commands/__init__.py b/astrbot/cli/client/commands/__init__.py index 6a55873070..a59fecbd80 100644 --- a/astrbot/cli/client/commands/__init__.py +++ b/astrbot/cli/client/commands/__init__.py @@ -4,7 +4,6 @@ from .conv import conv from .debug import ping, status, test -from .interactive import interactive from .log import log from .plugin import plugin from .provider import key, model, provider @@ -45,9 +44,6 @@ def register_commands(group): # 函数工具管理 group.add_command(tool) - # 交互模式 - group.add_command(interactive) - # 快捷别名（独立命令，映射到 send /cmd） _register_aliases(group) diff --git a/astrbot/cli/client/commands/interactive.py b/astrbot/cli/client/commands/interactive.py deleted file mode 100644 index b37e85ce1c..0000000000 --- a/astrbot/cli/client/commands/interactive.py +++ /dev/null @@ -1,103 +0,0 @@ -"""交互式 REPL 模式 - astr interactive""" - -import click - -from ..connection import send_message -from ..output import format_response - - -@click.command(help="进入交互式 REPL 模式") -def interactive() -> None: - """进入交互式 REPL 模式 - - \b - 特性: - - 直接输入消息发送给 AstrBot - - 支持 CLI 子命令（如 conv ls, plugin ls） - - /quit 或 Ctrl+C 退出 - - 支持命令历史（readline） - - \b - 示例: - astr interactive 进入交互模式 - astr -i 同上（快捷方式） - """ - # 子命令映射：REPL 中输入的前缀 -> 对应的内部命令格式 - _REPL_COMMAND_MAP = { - "conv ls": "/ls", - "conv new": "/new", - "conv switch": "/switch", - "conv del": "/del", - "conv rename": "/rename", - "conv reset": "/reset", - "conv history": "/history", - "plugin ls": "/plugin ls", - "plugin on": "/plugin on", - "plugin off": "/plugin off", - "plugin help": "/plugin help", - "provider": "/provider", - "model": "/model", - "key": "/key", - "help": "/help", - "sid": "/sid", - "t2i": "/t2i", - "tts": "/tts", - } - - # 尝试启用 readline 支持命令历史 - try: - import readline # noqa: F401 - except ImportError: - pass - - click.echo("AstrBot 交互模式 (输入 /quit 或 Ctrl+C 退出)") - click.echo("---") - - while True: - try: - line = input("astr> ").strip() - except (EOFError, KeyboardInterrupt): - click.echo("\n再见!") - break - - if not line: - continue - - if line in ("/quit", "/exit", "quit", "exit"): - click.echo("再见!") - break - - # 尝试匹配 REPL 子命令 - msg = _resolve_repl_command(line, _REPL_COMMAND_MAP) - - response = send_message(msg) - if response.get("status") == "success": - formatted = format_response(response) - if formatted: - click.echo(formatted) - else: - error = response.get("error", "Unknown error") - click.echo(f"Error: {error}", err=True) - - -def _resolve_repl_command(line: str, command_map: dict[str, str]) -> str: - """将 REPL 输入解析为内部命令 - - 先尝试匹配最长前缀的子命令映射，未匹配则原样发送。 - - Args: - line: 用户输入 - command_map: 子命令映射表 - - Returns: - 要发送的消息 - """ - # 按键长度降序匹配，确保 "conv ls" 优先于 "conv" - for prefix in sorted(command_map, key=len, reverse=True): - if line == prefix: - return command_map[prefix] - if line.startswith(prefix + " "): - rest = line[len(prefix) :].strip() - return f"{command_map[prefix]} {rest}" - - return line diff --git a/astrbot/core/platform/sources/cli/cli_adapter.py b/astrbot/core/platform/sources/cli/cli_adapter.py index 088a731144..f5fb284f1a 100644 --- a/astrbot/core/platform/sources/cli/cli_adapter.py +++ b/astrbot/core/platform/sources/cli/cli_adapter.py @@ -26,7 +26,6 @@ write_connection_info, ) from .socket_server import create_socket_server, detect_platform -from .tty_handler import TTYHandler # ------------------------------------------------------------------ # Token管理 @@ -275,17 +274,10 @@ async def _run_loop(self) -> None: try: if self.mode == "socket": await self._run_socket_mode() - elif self.mode == "tty": - await self._run_tty_mode() elif self.mode == "file": await self._run_file_mode() else: - import sys - - if sys.stdin.isatty(): - await self._run_tty_mode() - else: - await self._run_socket_mode() + await self._run_socket_mode() finally: self._running = False await self.session_manager.stop_cleanup_task() @@ -323,15 +315,6 @@ async def _run_socket_mode(self) -> None: await self._handler.run() - async def _run_tty_mode(self) -> None: - self._handler = TTYHandler( - message_converter=self.message_converter, - platform_meta=self.metadata, - output_queue=self._output_queue, - event_committer=self.commit_event, - ) - await self._handler.run() - async def _run_file_mode(self) -> None: self._handler = FileHandler( input_file=self.input_file, diff --git a/astrbot/core/platform/sources/cli/tty_handler.py b/astrbot/core/platform/sources/cli/tty_handler.py deleted file mode 100644 index e3a87e42ad..0000000000 --- a/astrbot/core/platform/sources/cli/tty_handler.py +++ /dev/null @@ -1,100 +0,0 @@ -"""TTY交互模式处理器""" - -import asyncio -from collections.abc import Callable -from typing import TYPE_CHECKING - -from astrbot import logger -from astrbot.core.message.message_event_result import MessageChain - -if TYPE_CHECKING: - from astrbot.core.platform.platform_metadata import PlatformMetadata - - from .cli_event import CLIMessageEvent - - -class TTYHandler: - """TTY交互模式处理器""" - - EXIT_COMMANDS = frozenset({"exit", "quit"}) - BANNER = """ -============================================================ -AstrBot CLI Simulator -============================================================ -Type your message and press Enter to send. -Type 'exit' or 'quit' to stop. -============================================================ -""" - - def __init__( - self, - message_converter, - platform_meta: "PlatformMetadata", - output_queue: asyncio.Queue, - event_committer: Callable[["CLIMessageEvent"], None], - ): - self.message_converter = message_converter - self.platform_meta = platform_meta - self.output_queue = output_queue - self.event_committer = event_committer - self._running = False - - async def run(self) -> None: - self._running = True - print(self.BANNER) - - output_task = asyncio.create_task(self._output_loop()) - - try: - await self._input_loop() - except KeyboardInterrupt: - logger.info("[CLI] Received KeyboardInterrupt") - finally: - self._running = False - output_task.cancel() - try: - await output_task - except asyncio.CancelledError: - pass - - def stop(self) -> None: - self._running = False - - async def _input_loop(self) -> None: - loop = asyncio.get_running_loop() - while self._running: - user_input = await loop.run_in_executor(None, input, "You: ") - user_input = user_input.strip() - if not user_input: - continue - if user_input.lower() in self.EXIT_COMMANDS: - break - await self._handle_input(user_input) - - async def _handle_input(self, text: str) -> None: - from .cli_event import CLIMessageEvent - - message = self.message_converter.convert(text) - message_event = CLIMessageEvent( - message_str=message.message_str, - message_obj=message, - platform_meta=self.platform_meta, - session_id=message.session_id, - output_queue=self.output_queue, - ) - self.event_committer(message_event) - - async def _output_loop(self) -> None: - while self._running: - try: - message_chain = await asyncio.wait_for( - self.output_queue.get(), timeout=0.5 - ) - self._print_response(message_chain) - except asyncio.TimeoutError: - continue - except asyncio.CancelledError: - break - - def _print_response(self, message_chain: MessageChain) -> None: - print(f"\nBot: {message_chain.get_plain_text()}\n") diff --git a/tests/test_cli/test_client_commands.py b/tests/test_cli/test_client_commands.py index bef31fb8e1..8790b58be7 100644 --- a/tests/test_cli/test_client_commands.py +++ b/tests/test_cli/test_client_commands.py @@ -542,21 +542,6 @@ def test_help_output(self): assert "plugin" in result.output assert "provider" in result.output assert "ping" in result.output - assert "interactive" in result.output - - -class TestInteractiveFlag: - """交互模式快捷方式测试""" - - @patch("astrbot.cli.client.commands.interactive.send_message") - def test_interactive_flag(self, mock_send): - """astr -i → astr interactive""" - runner = CliRunner() - # 输入 /quit 以退出交互模式 - result = runner.invoke(main, ["-i"], input="/quit\n") - - assert result.exit_code == 0 - assert "再见" in result.output class TestSessionCommand: diff --git a/tests/test_cli/test_client_interactive.py b/tests/test_cli/test_client_interactive.py deleted file mode 100644 index b56ab3428b..0000000000 --- a/tests/test_cli/test_client_interactive.py +++ /dev/null @@ -1,206 +0,0 @@ -"""CLI Client 交互模式单元测试""" - -from unittest.mock import patch - -from astrbot.cli.client.commands.interactive import _resolve_repl_command - - -class TestResolveReplCommand: - """REPL 命令解析测试""" - - def setup_method(self): - """设置命令映射表""" - self.command_map = { - "conv ls": "/ls", - "conv new": "/new", - "conv switch": "/switch", - "conv del": "/del", - "conv rename": "/rename", - "conv reset": "/reset", - "conv history": "/history", - "plugin ls": "/plugin ls", - "plugin on": "/plugin on", - "plugin off": "/plugin off", - "plugin help": "/plugin help", - "provider": "/provider", - "model": "/model", - "key": "/key", - "help": "/help", - "sid": "/sid", - "t2i": "/t2i", - "tts": "/tts", - } - - def test_conv_ls(self): - """conv ls 映射到 /ls""" - assert _resolve_repl_command("conv ls", self.command_map) == "/ls" - - def test_conv_ls_with_page(self): - """conv ls 2 映射到 /ls 2""" - assert _resolve_repl_command("conv ls 2", self.command_map) == "/ls 2" - - def test_conv_switch(self): - """conv switch 3 映射到 /switch 3""" - assert _resolve_repl_command("conv switch 3", self.command_map) == "/switch 3" - - def test_conv_rename(self): - """conv rename 新名称 映射""" - assert ( - _resolve_repl_command("conv rename 新名称", self.command_map) - == "/rename 新名称" - ) - - def test_plugin_ls(self): - """plugin ls 映射""" - assert _resolve_repl_command("plugin ls", self.command_map) == "/plugin ls" - - def test_plugin_on(self): - """plugin on name 映射""" - assert ( - _resolve_repl_command("plugin on myplugin", self.command_map) - == "/plugin on myplugin" - ) - - def test_provider(self): - """provider 映射""" - assert _resolve_repl_command("provider", self.command_map) == "/provider" - - def test_provider_with_index(self): - """provider 1 映射""" - assert _resolve_repl_command("provider 1", self.command_map) == "/provider 1" - - def test_model(self): - """model 映射""" - assert _resolve_repl_command("model", self.command_map) == "/model" - - def test_model_with_name(self): - """model gpt-4 映射""" - assert _resolve_repl_command("model gpt-4", self.command_map) == "/model gpt-4" - - def test_help(self): - """help 映射""" - assert _resolve_repl_command("help", self.command_map) == "/help" - - def test_sid(self): - """sid 映射""" - assert _resolve_repl_command("sid", self.command_map) == "/sid" - - def test_passthrough_message(self): - """普通消息原样传递""" - assert _resolve_repl_command("你好", self.command_map) == "你好" - - def test_passthrough_slash_command(self): - """斜杠命令原样传递""" - assert _resolve_repl_command("/help", self.command_map) == "/help" - - def test_passthrough_unknown(self): - """未知命令原样传递""" - assert _resolve_repl_command("unknown cmd", self.command_map) == "unknown cmd" - - def test_exact_match_priority(self): - """精确匹配优先于前缀匹配""" - assert _resolve_repl_command("conv ls", self.command_map) == "/ls" - - def test_key(self): - """key 映射""" - assert _resolve_repl_command("key", self.command_map) == "/key" - - def test_key_with_index(self): - """key 1 映射""" - assert _resolve_repl_command("key 1", self.command_map) == "/key 1" - - def test_t2i(self): - """t2i 映射""" - assert _resolve_repl_command("t2i", self.command_map) == "/t2i" - - def test_tts(self): - """tts 映射""" - assert _resolve_repl_command("tts", self.command_map) == "/tts" - - -class TestInteractiveRepl: - """交互模式 REPL 测试""" - - @patch("astrbot.cli.client.commands.interactive.send_message") - def test_quit(self, mock_send): - """输入 /quit 退出""" - from click.testing import CliRunner - - from astrbot.cli.client.commands.interactive import interactive - - runner = CliRunner() - result = runner.invoke(interactive, input="/quit\n") - - assert result.exit_code == 0 - assert "再见" in result.output - - @patch("astrbot.cli.client.commands.interactive.send_message") - def test_exit(self, mock_send): - """输入 exit 退出""" - from click.testing import CliRunner - - from astrbot.cli.client.commands.interactive import interactive - - runner = CliRunner() - result = runner.invoke(interactive, input="exit\n") - - assert result.exit_code == 0 - assert "再见" in result.output - - @patch("astrbot.cli.client.commands.interactive.send_message") - def test_send_message(self, mock_send): - """在 REPL 中发送消息""" - from click.testing import CliRunner - - from astrbot.cli.client.commands.interactive import interactive - - mock_send.return_value = {"status": "success", "response": "hi", "images": []} - - runner = CliRunner() - result = runner.invoke(interactive, input="你好\n/quit\n") - - assert result.exit_code == 0 - mock_send.assert_any_call("你好") - - @patch("astrbot.cli.client.commands.interactive.send_message") - def test_empty_line_ignored(self, mock_send): - """空行被忽略""" - from click.testing import CliRunner - - from astrbot.cli.client.commands.interactive import interactive - - runner = CliRunner() - result = runner.invoke(interactive, input="\n\n/quit\n") - - assert result.exit_code == 0 - mock_send.assert_not_called() - - @patch("astrbot.cli.client.commands.interactive.send_message") - def test_repl_command_mapping(self, mock_send): - """REPL 中子命令映射""" - from click.testing import CliRunner - - from astrbot.cli.client.commands.interactive import interactive - - mock_send.return_value = {"status": "success", "response": "ok", "images": []} - - runner = CliRunner() - result = runner.invoke(interactive, input="conv ls\n/quit\n") - - assert result.exit_code == 0 - mock_send.assert_any_call("/ls") - - @patch("astrbot.cli.client.commands.interactive.send_message") - def test_error_response(self, mock_send): - """错误响应显示""" - from click.testing import CliRunner - - from astrbot.cli.client.commands.interactive import interactive - - mock_send.return_value = {"status": "error", "error": "Connection failed"} - - runner = CliRunner() - result = runner.invoke(interactive, input="hello\n/quit\n") - - assert result.exit_code == 0 - assert "Connection failed" in result.output From 331226d7713800d38ec5a0116992de0f40e2956d Mon Sep 17 00:00:00 2001 From: YukiRa1n <167516635+YukiRa1n@users.noreply.github.com> Date: Wed, 25 Feb 2026 16:04:05 +0800 Subject: [PATCH 39/39] feat(cli): add astrbot stop command to terminate running processes --- astrbot/cli/__main__.py | 3 +- astrbot/cli/commands/__init__.py | 3 +- astrbot/cli/commands/cmd_stop.py | 150 +++++++++++++++++++++++++++++++ 3 files changed, 154 insertions(+), 2 deletions(-) create mode 100644 astrbot/cli/commands/cmd_stop.py diff --git a/astrbot/cli/__main__.py b/astrbot/cli/__main__.py index 47f5a8eec5..e773b994f4 100644 --- a/astrbot/cli/__main__.py +++ b/astrbot/cli/__main__.py @@ -5,7 +5,7 @@ import click from . import __version__ -from .commands import conf, init, plug, restart, run +from .commands import conf, init, plug, restart, run, stop logo_tmpl = r""" ___ _______.___________..______ .______ ______ .___________. @@ -52,6 +52,7 @@ def help(command_name: str | None) -> None: cli.add_command(init) cli.add_command(run) cli.add_command(restart) +cli.add_command(stop) cli.add_command(help) cli.add_command(plug) cli.add_command(conf) diff --git a/astrbot/cli/commands/__init__.py b/astrbot/cli/commands/__init__.py index 69c22a2183..f3f56c1da8 100644 --- a/astrbot/cli/commands/__init__.py +++ b/astrbot/cli/commands/__init__.py @@ -3,5 +3,6 @@ from .cmd_plug import plug from .cmd_restart import restart from .cmd_run import run +from .cmd_stop import stop -__all__ = ["conf", "init", "plug", "restart", "run"] +__all__ = ["conf", "init", "plug", "restart", "run", "stop"] diff --git a/astrbot/cli/commands/cmd_stop.py b/astrbot/cli/commands/cmd_stop.py new file mode 100644 index 0000000000..414bf17f73 --- /dev/null +++ b/astrbot/cli/commands/cmd_stop.py @@ -0,0 +1,150 @@ +import os +import signal +import subprocess +import sys +import time + +import click + +from ..utils import check_astrbot_root, get_astrbot_root + + +def find_and_kill_astrbot_processes(astrbot_root: str) -> bool: + """查找并终止正在运行的 AstrBot 进程 + + Returns: + bool: 是否成功终止了进程 + """ + killed = False + current_pid = os.getpid() + + if sys.platform == "win32": + # Windows: 使用 wmic 获取进程命令行，精确匹配 AstrBot 进程 + try: + result = subprocess.run( + [ + "wmic", + "process", + "where", + "name='python.exe'", + "get", + "processid,commandline", + "/format:csv", + ], + capture_output=True, + text=True, + timeout=10, + ) + + for line in result.stdout.split("\n"): + if not line.strip() or "CommandLine" in line: + continue + + parts = line.split(",") + if len(parts) >= 3: + _, cmdline, pid_str = ( + parts[0].strip('"'), + parts[1].strip('"'), + parts[2].strip('"'), + ) + + try: + pid = int(pid_str) + + if pid == current_pid: + continue + + cmdline_lower = cmdline.lower() + if "astrbot" in cmdline_lower or "astrbot.exe" in cmdline_lower: + subprocess.run( + ["taskkill", "/F", "/T", "/PID", str(pid)], + capture_output=True, + timeout=5, + ) + click.echo(f"已终止进程: {pid}") + killed = True + except (ValueError, subprocess.TimeoutExpired): + continue + except (subprocess.CalledProcessError, FileNotFoundError, Exception) as e: + click.echo(f"查找进程时出错: {e}") + + else: + # Unix/Linux/macOS: 使用 ps 和 kill + try: + result = subprocess.run( + ["ps", "aux"], + capture_output=True, + text=True, + timeout=10, + ) + + for line in result.stdout.split("\n"): + if line.startswith("USER"): + continue + + if "python" in line.lower() and "astrbot" in line.lower(): + parts = line.split(None, 10) + if len(parts) >= 2: + try: + pid = int(parts[1]) + + if pid == current_pid: + continue + + os.kill(pid, signal.SIGTERM) + click.echo(f"已发送 SIGTERM 到进程: {pid}") + killed = True + except (ValueError, ProcessLookupError): + continue + except Exception as e: + click.echo(f"查找进程时出错: {e}") + + return killed + + +@click.option( + "--wait-time", + type=float, + default=3.0, + help="等待进程退出的时间（秒）", +) +@click.option( + "--force", + "-f", + is_flag=True, + help="强制终止，删除锁文件", +) +@click.command() +def stop(wait_time: float, force: bool) -> None: + """停止 AstrBot 进程""" + try: + os.environ["ASTRBOT_CLI"] = "1" + astrbot_root = get_astrbot_root() + + if not check_astrbot_root(astrbot_root): + raise click.ClickException( + f"{astrbot_root}不是有效的 AstrBot 根目录", + ) + + # 查找并终止进程 + killed = find_and_kill_astrbot_processes(astrbot_root) + + if killed: + click.echo(f"等待 {wait_time} 秒以确保进程退出...") + time.sleep(wait_time) + + # 删除锁文件 + if force: + lock_file = astrbot_root / "astrbot.lock" + try: + lock_file.unlink(missing_ok=True) + click.echo("已删除锁文件") + except Exception as e: + click.echo(f"删除锁文件失败: {e}") + + click.echo("[OK] AstrBot 已停止") + else: + click.echo("未找到正在运行的 AstrBot 进程") + + except Exception as e: + raise click.ClickException(f"停止时出现错误: {e}")