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.

Author: YukiRa1n

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,18 +223,22 @@ def send_message(
             # 尝试解析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()
@@ -130,14 +247,18 @@ 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:
   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.
         """,
     )
 

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客户端连接