astrbotmcp 0.3.0__py3-none-any.whl → 0.4.0__py3-none-any.whl

astrbot_mcp/astrbot_client.py

@@ -98,7 +98,16 @@ class AstrBotClient:
             pwd = hashlib.md5(pwd.encode("utf-8")).hexdigest()
 
         url = f"{self.base_url}/api/auth/login"
-        client_kwargs = {"timeout": self.timeout}
+        # SSE endpoints can legitimately stay quiet for a long time while work is happening.
+        # Use an infinite read timeout, while keeping connect/write/pool bounded.
+        client_kwargs = {
+            "timeout": httpx.Timeout(
+                connect=self.timeout,
+                read=None,
+                write=self.timeout,
+                pool=self.timeout,
+            )
+        }
         if self.settings.disable_proxy:
             client_kwargs["trust_env"] = False  # 禁用代理，忽略环境变量设置
 
@@ -175,9 +184,12 @@ class AstrBotClient:
         max_events: Optional[int] = None,
     ) -> List[Dict[str, Any]]:
         """
-        Consume a simple SSE endpoint and return parsed JSON payloads.
+        Consume an SSE endpoint and return parsed event payloads.
 
-        AstrBot's SSE endpoints use `data: {...}\\n\\n` format per event.
+        AstrBot's SSE endpoints typically use `data: {...}\\n\\n` format per event.
+        This parser is tolerant:
+          - Supports multi-line `data:` frames per SSE spec (joined with `\\n`).
+          - If `data:` is not valid JSON, returns it as `{\"type\":\"raw\",\"data\":...}`.
 
         `max_seconds` is a soft upper bound for how long we wait:
         - 如果持续有事件流入，最多等待约 `max_seconds` 秒；
@@ -223,31 +235,63 @@ class AstrBotClient:
                     )
 
                 async def consume() -> None:
-                    async for line in response.aiter_lines():
-                        if not line:
-                            # Heartbeats / blank lines
-                            continue
-
-                        if not line.startswith("data:"):
-                            continue
+                    current_event: str | None = None
+                    data_lines: List[str] = []
 
-                        _, data_str = line.split("data:", 1)
-                        data_str = data_str.strip()
+                    def flush() -> None:
+                        nonlocal current_event, data_lines
+                        if not data_lines:
+                            current_event = None
+                            return
+                        data_str = "\n".join(data_lines).strip()
+                        data_lines = []
 
                         if not data_str:
-                            continue
+                            current_event = None
+                            return
 
                         try:
                             payload = json.loads(data_str)
                         except json.JSONDecodeError:
-                            continue
+                            payload = None
 
                         if isinstance(payload, dict):
+                            if current_event and "event" not in payload:
+                                payload = {**payload, "event": current_event}
                             events.append(payload)
+                        else:
+                            events.append(
+                                {
+                                    "type": "raw",
+                                    "event": current_event,
+                                    "data": data_str,
+                                }
+                            )
+                        current_event = None
 
-                        if max_events is not None and len(events) >= max_events:
-                            # Enough events collected; stop consuming.
-                            break
+                    async for line in response.aiter_lines():
+                        # Blank line terminates an SSE event.
+                        if line == "":
+                            flush()
+                            if max_events is not None and len(events) >= max_events:
+                                break
+                            continue
+
+                        # Comments / heartbeats
+                        if line.startswith(":"):
+                            continue
+
+                        if line.startswith("event:"):
+                            current_event = line.split("event:", 1)[1].strip() or None
+                            continue
+
+                        if line.startswith("data:"):
+                            data_lines.append(line.split("data:", 1)[1].lstrip())
+                            continue
+
+                        continue
+
+                    flush()
 
                 if max_seconds is not None and max_seconds > 0:
                     try:
@@ -358,6 +402,38 @@ class AstrBotClient:
         response = await self._request("POST", "/api/config/astrbot/update", json_body=payload)
         return response.json()
 
+    async def get_plugin_config(
+        self,
+        *,
+        plugin_name: str,
+    ) -> Dict[str, Any]:
+        """
+        Get plugin config via /api/config/get?plugin_name=<name>.
+        """
+        response = await self._request(
+            "GET",
+            "/api/config/get",
+            params={"plugin_name": plugin_name},
+        )
+        return response.json()
+
+    async def update_plugin_config(
+        self,
+        *,
+        plugin_name: str,
+        config: Dict[str, Any],
+    ) -> Dict[str, Any]:
+        """
+        Update plugin config via /api/config/plugin/update?plugin_name=<name>.
+        """
+        response = await self._request(
+            "POST",
+            "/api/config/plugin/update",
+            params={"plugin_name": plugin_name},
+            json_body=config,
+        )
+        return response.json()
+
     async def list_session_rules(
         self,
         *,
@@ -414,6 +490,40 @@ class AstrBotClient:
         response = await self._request("GET", "/api/plugin/market_list", params=params or None)
         return response.json()
 
+    async def install_plugin_from_url(
+        self,
+        *,
+        url: str,
+        proxy: str | None = None,
+    ) -> Dict[str, Any]:
+        """
+        Install a plugin from repository URL via /api/plugin/install.
+        """
+        payload: Dict[str, Any] = {"url": url}
+        if proxy:
+            payload["proxy"] = proxy
+        response = await self._request("POST", "/api/plugin/install", json_body=payload)
+        return response.json()
+
+    async def install_plugin_from_file(
+        self,
+        file_path: str,
+    ) -> Dict[str, Any]:
+        """
+        Install a plugin from uploaded zip file via /api/plugin/install-upload.
+        """
+        send_name = os.path.basename(file_path)
+        with open(file_path, "rb") as f:
+            files = {
+                "file": (send_name, f, "application/zip"),
+            }
+            response = await self._request(
+                "POST",
+                "/api/plugin/install-upload",
+                files=files,
+            )
+            return response.json()
+
     # ---- Chat / platform session APIs --------------------------------
 
     async def create_platform_session(
@@ -648,3 +758,52 @@ class AstrBotClient:
         """
         response = await self._request("GET", "/api/stat/version")
         return response.json()
+
+    # ---- MCP panel APIs ----------------------------------------------
+
+    async def get_mcp_servers(self) -> Dict[str, Any]:
+        """
+        Get MCP server list from panel API /api/tools/mcp/servers.
+        """
+        response = await self._request("GET", "/api/tools/mcp/servers")
+        return response.json()
+
+    async def add_mcp_server(self, payload: Dict[str, Any]) -> Dict[str, Any]:
+        """
+        Add MCP server via panel API /api/tools/mcp/add.
+        """
+        response = await self._request("POST", "/api/tools/mcp/add", json_body=payload)
+        return response.json()
+
+    async def update_mcp_server(self, payload: Dict[str, Any]) -> Dict[str, Any]:
+        """
+        Update MCP server via panel API /api/tools/mcp/update.
+        """
+        response = await self._request("POST", "/api/tools/mcp/update", json_body=payload)
+        return response.json()
+
+    async def delete_mcp_server(self, *, name: str) -> Dict[str, Any]:
+        """
+        Delete MCP server via panel API /api/tools/mcp/delete.
+        """
+        response = await self._request(
+            "POST",
+            "/api/tools/mcp/delete",
+            json_body={"name": name},
+        )
+        return response.json()
+
+    async def test_mcp_server_connection(
+        self,
+        *,
+        mcp_server_config: Dict[str, Any],
+    ) -> Dict[str, Any]:
+        """
+        Test MCP connection via panel API /api/tools/mcp/test.
+        """
+        response = await self._request(
+            "POST",
+            "/api/tools/mcp/test",
+            json_body={"mcp_server_config": mcp_server_config},
+        )
+        return response.json()

astrbot_mcp/config.py

@@ -15,7 +15,6 @@ class AstrBotSettings:
     default_provider: str | None = None
     default_model: str | None = None
     file_root: str | None = None
-    direct_media_mode: str | None = None
     disable_proxy: bool = True  # 默认禁用代理，防止本地请求被代理拦截
 
 
@@ -41,10 +40,6 @@ def get_settings() -> AstrBotSettings:
       - ASTRBOT_DEFAULT_PROVIDER: Default provider id to use for /api/chat/send.
       - ASTRBOT_DEFAULT_MODEL: Default model id to use for /api/chat/send.
       - ASTRBOTMCP_FILE_ROOT: Base directory for resolving relative local file_path.
-      - ASTRBOTMCP_DIRECT_MEDIA_MODE: How send_platform_message_direct handles local media:
-        - auto (default): try local path first, then fallback to upload+URL.
-        - local: always send local absolute paths to AstrBot platform adapters.
-        - upload: upload to AstrBot first and send an http(s) URL.
     """
     base_url = _get_env("ASTRBOT_BASE_URL")
     if not base_url:
@@ -69,9 +64,6 @@ def get_settings() -> AstrBotSettings:
     default_provider = _get_env("ASTRBOT_DEFAULT_PROVIDER")
     default_model = _get_env("ASTRBOT_DEFAULT_MODEL")
     file_root = _get_env("ASTRBOTMCP_FILE_ROOT") or _get_env("ASTRBOT_MCP_FILE_ROOT")
-    direct_media_mode = _get_env("ASTRBOTMCP_DIRECT_MEDIA_MODE") or _get_env(
-        "ASTRBOT_MCP_DIRECT_MEDIA_MODE"
-    )
 
     # 默认禁用代理，除非明确设置为false
     disable_proxy_str = _get_env("ASTRBOTMCP_DISABLE_PROXY")
@@ -87,6 +79,5 @@ def get_settings() -> AstrBotSettings:
         default_provider=default_provider,
         default_model=default_model,
         file_root=file_root,
-        direct_media_mode=direct_media_mode,
         disable_proxy=disable_proxy,
     )

astrbot_mcp/server.py

@@ -15,6 +15,7 @@ server = FastMCP(
         "MCP server for interacting with an existing AstrBot instance. "
         "Provides tools to read logs, list configured message platforms, "
         "send message chains (including files) via the web chat API, "
+        "install/configure plugins, manage MCP panel config, "
         "restart AstrBot core, read platform session message history, "
         "and browse the AstrBot plugin market."
     ),
@@ -23,7 +24,6 @@ server = FastMCP(
 # Register tools with FastMCP
 server.tool(astrbot_tools.get_astrbot_logs, name="get_astrbot_logs")
 server.tool(astrbot_tools.get_message_platforms, name="get_message_platforms")
-server.tool(astrbot_tools.send_platform_message_direct, name="send_platform_message_direct")
 server.tool(astrbot_tools.send_platform_message, name="send_platform_message")
 server.tool(astrbot_tools.restart_astrbot, name="restart_astrbot")
 server.tool(
@@ -31,6 +31,12 @@ server.tool(
     name="get_platform_session_messages",
 )
 server.tool(astrbot_tools.browse_plugin_market, name="browse_plugin_market")
+server.tool(astrbot_tools.install_astrbot_plugin, name="install_astrbot_plugin")
+server.tool(
+    astrbot_tools.configure_astrbot_plugin_json,
+    name="configure_astrbot_plugin_json",
+)
+server.tool(astrbot_tools.manage_mcp_config_panel, name="manage_mcp_config_panel")
 server.tool(astrbot_tools.list_astrbot_config_files, name="list_astrbot_config_files")
 server.tool(astrbot_tools.inspect_astrbot_config, name="inspect_astrbot_config")
 server.tool(astrbot_tools.apply_astrbot_config_ops, name="apply_astrbot_config_ops")
@@ -49,10 +55,12 @@ def astrbot_info():
             "get_astrbot_logs",
             "get_message_platforms",
             "send_platform_message",
-            "send_platform_message_direct",
             "restart_astrbot",
             "get_platform_session_messages",
             "browse_plugin_market",
+            "install_astrbot_plugin",
+            "configure_astrbot_plugin_json",
+            "manage_mcp_config_panel",
             "list_astrbot_config_files",
             "inspect_astrbot_config",
             "apply_astrbot_config_ops",

astrbot_mcp/tools/__init__.py

@@ -18,13 +18,14 @@ All functions are re-exported from this module for convenience.
 # 导入所有工具函数，保持向后兼容
 from .control_tools import restart_astrbot
 from .log_tools import get_astrbot_logs
-from .message_tools import (
+from .message import (
     send_platform_message,
-    send_platform_message_direct,
 )
 from .platform_tools import get_message_platforms
 from .session_tools import get_platform_session_messages
 from .plugin_market_tools import browse_plugin_market
+from .plugin_admin_tools import install_astrbot_plugin, configure_astrbot_plugin_json
+from .mcp_panel_tools import manage_mcp_config_panel
 from .config_tools import (
     list_astrbot_config_files,
     inspect_astrbot_config,
@@ -40,7 +41,6 @@ from .helpers import (
     _as_file_uri,
     _attachment_download_url,
     _astrbot_connect_hint,
-    _direct_media_mode,
     _httpx_error_detail,
     _resolve_local_file_path,
 )
@@ -49,11 +49,13 @@ __all__ = [
     # 工具函数
     "get_astrbot_logs",
     "get_message_platforms",
-    "send_platform_message_direct",
     "send_platform_message",
     "restart_astrbot",
     "get_platform_session_messages",
     "browse_plugin_market",
+    "install_astrbot_plugin",
+    "configure_astrbot_plugin_json",
+    "manage_mcp_config_panel",
     "list_astrbot_config_files",
     "inspect_astrbot_config",
     "apply_astrbot_config_ops",
@@ -67,6 +69,5 @@ __all__ = [
     "_attachment_download_url",
     "_astrbot_connect_hint",
     "_httpx_error_detail",
-    "_direct_media_mode",
     "_as_file_uri",
 ]

astrbot_mcp/tools/mcp_panel_tools.py

@@ -0,0 +1,135 @@
+from __future__ import annotations
+
+from typing import Any, Dict, Literal, Optional
+
+from ..astrbot_client import AstrBotClient
+from .helpers import _astrbot_connect_hint, _httpx_error_detail
+
+
+async def _get_astrbot_log_tail(
+    client: AstrBotClient,
+    *,
+    limit: int = 120,
+) -> Dict[str, Any] | None:
+    try:
+        hist = await client.get_log_history()
+    except Exception as e:
+        return {
+            "status": "error",
+            "message": f"AstrBot API error: {getattr(getattr(e, 'response', None), 'status_code', None) or 'Unknown'}",
+            "detail": _httpx_error_detail(e),
+        }
+
+    if hist.get("status") != "ok":
+        return {
+            "status": hist.get("status"),
+            "message": hist.get("message"),
+            "raw": hist,
+        }
+
+    logs = (hist.get("data") or {}).get("logs", [])
+    if not isinstance(logs, list):
+        return {
+            "status": "error",
+            "message": "Unexpected /api/log-history response shape (logs is not a list).",
+            "raw": hist,
+        }
+    return {"status": "ok", "logs": logs[-max(1, int(limit)) :]}
+
+
+async def manage_mcp_config_panel(
+    action: Literal["list", "add", "update", "delete", "test"] = "list",
+    name: Optional[str] = None,
+    server_config: Optional[Dict[str, Any]] = None,
+    active: Optional[bool] = None,
+    include_logs: bool = True,
+    log_tail_limit: int = 120,
+) -> Dict[str, Any]:
+    """
+    Manage AstrBot MCP config panel APIs.
+
+    Actions:
+      - list:   GET /api/tools/mcp/servers
+      - add:    POST /api/tools/mcp/add
+      - update: POST /api/tools/mcp/update
+      - delete: POST /api/tools/mcp/delete
+      - test:   POST /api/tools/mcp/test
+    """
+    client = AstrBotClient.from_env()
+
+    try:
+        if action == "list":
+            raw = await client.get_mcp_servers()
+        elif action == "add":
+            if not name or not str(name).strip():
+                return {"status": "error", "message": "name is required for action='add'."}
+            if not isinstance(server_config, dict) or not server_config:
+                return {
+                    "status": "error",
+                    "message": "server_config is required for action='add'.",
+                }
+            payload = {"name": str(name).strip(), **server_config}
+            if active is not None:
+                payload["active"] = bool(active)
+            raw = await client.add_mcp_server(payload)
+        elif action == "update":
+            if not name or not str(name).strip():
+                return {"status": "error", "message": "name is required for action='update'."}
+            payload = {"name": str(name).strip()}
+            if isinstance(server_config, dict):
+                payload.update(server_config)
+            if active is not None:
+                payload["active"] = bool(active)
+            raw = await client.update_mcp_server(payload)
+        elif action == "delete":
+            if not name or not str(name).strip():
+                return {
+                    "status": "error",
+                    "message": "name is required for action='delete'.",
+                }
+            raw = await client.delete_mcp_server(name=str(name).strip())
+        else:  # test
+            if not isinstance(server_config, dict) or not server_config:
+                return {
+                    "status": "error",
+                    "message": "server_config is required for action='test'.",
+                }
+            raw = await client.test_mcp_server_connection(
+                mcp_server_config=server_config
+            )
+    except Exception as e:
+        payload = {
+            "status": "error",
+            "message": _astrbot_connect_hint(client),
+            "base_url": client.base_url,
+            "detail": _httpx_error_detail(e),
+            "action": action,
+            "name": name,
+        }
+        if include_logs:
+            payload["astrbot_logs_tail"] = await _get_astrbot_log_tail(
+                client, limit=log_tail_limit
+            )
+        return payload
+
+    payload: Dict[str, Any] = {
+        "status": raw.get("status", "ok"),
+        "message": raw.get("message"),
+        "action": action,
+        "name": name,
+        "raw": raw,
+    }
+    if action == "list" and raw.get("status") == "ok":
+        servers = raw.get("data") if isinstance(raw.get("data"), list) else []
+        payload["servers"] = servers
+        payload["mcp_server_errlogs"] = [
+            {"name": s.get("name"), "errlogs": s.get("errlogs")}
+            for s in servers
+            if isinstance(s, dict) and s.get("errlogs")
+        ]
+
+    if include_logs:
+        payload["astrbot_logs_tail"] = await _get_astrbot_log_tail(
+            client, limit=log_tail_limit
+        )
+    return payload

astrbot_mcp/tools/message/__init__.py

@@ -0,0 +1,3 @@
+from .webchat import send_platform_message
+
+__all__ = ["send_platform_message"]

astrbot_mcp/tools/message/cache.py

@@ -0,0 +1,23 @@
+from __future__ import annotations
+
+import asyncio
+from typing import Dict, Tuple
+
+from ...astrbot_client import AstrBotClient
+
+_SESSION_CACHE_LOCK = asyncio.Lock()
+_SESSION_CACHE: Dict[Tuple[str, str, str], str] = {}
+
+_LAST_SAVED_MESSAGE_ID_LOCK = asyncio.Lock()
+_LAST_SAVED_MESSAGE_ID_BY_SESSION: Dict[Tuple[str, str, str], str] = {}
+
+_LAST_USER_MESSAGE_ID_LOCK = asyncio.Lock()
+_LAST_USER_MESSAGE_ID_BY_SESSION: Dict[Tuple[str, str, str], str] = {}
+
+
+def _session_cache_key(client: AstrBotClient, platform_id: str) -> Tuple[str, str, str]:
+    return (client.base_url, client.settings.username or "", platform_id)
+
+
+def _last_saved_key(client: AstrBotClient, session_id: str) -> Tuple[str, str, str]:
+    return (client.base_url, client.settings.username or "", session_id)