mofox-plugin-dev-toolkit 0.2.1__py3-none-any.whl

mpdt/dev/bridge_plugin/plugin.py

@@ -0,0 +1,258 @@
+"""
+DevBridge 插件 - 为 mpdt dev 提供 WebSocket 桥接
+临时注入到主程序，提供插件重载接口
+"""
+
+import asyncio
+from typing import ClassVar, Set
+
+from fastapi import WebSocket, WebSocketDisconnect
+from src.common.logger import get_logger
+from src.common.security import VerifiedDep
+from src.common.server import get_global_server
+from src.plugin_system import (
+    BasePlugin,
+    register_plugin,
+)
+from src.plugin_system.apis.plugin_info_api import list_plugins
+from src.plugin_system.base.base_http_component import BaseRouterComponent
+from src.plugin_system.base.component_types import ComponentInfo
+
+logger = get_logger("dev_bridge")
+
+
+class DevBridgeRouter(BaseRouterComponent):
+    """开发模式 WebSocket 路由组件"""
+
+    component_name = "dev_bridge_router"
+    component_description = "开发模式 WebSocket 桥接，提供插件重载接口"
+    component_version = "1.0.0"
+
+    def __init__(self, plugin_config: dict | None = None):
+        """初始化路由组件"""
+        self.active_connections: Set[WebSocket] = set()
+        super().__init__(plugin_config)
+
+    def register_endpoints(self) -> None:
+        """注册 HTTP 端点"""
+
+        @self.router.websocket("/ws")
+        async def websocket_endpoint(websocket: WebSocket):
+            """WebSocket 端点 - 与 mpdt dev 通信
+
+            完整路径: ws://{host}:{port}/plugin-api/dev_bridge/dev_bridge_router/ws
+
+            消息格式:
+                客户端 → 服务器:
+                    {"command": "reload", "plugin_name": "xxx"}
+                    {"command": "status"}
+                    {"command": "ping"}
+                    {"command": "get_loaded_plugins"}
+
+                服务器 → 客户端:
+                    {"type": "reload_result", "success": true, "message": "..."}
+                    {"type": "status", "loaded_plugins": [...], "failed_plugins": [...]}
+                    {"type": "pong"}
+                    {"type": "plugins_loaded", "loaded": [...], "failed": [...]}
+            """
+            await websocket.accept()
+            self.active_connections.add(websocket)
+            logger.info("开发模式客户端已连接")
+
+            # 立即发送插件加载状态
+            try:
+                status = self._get_plugin_status()
+                await websocket.send_json({
+                    "type": "plugins_loaded",
+                    "loaded": status["loaded_plugins"],
+                    "failed": status["failed_plugins"]
+                })
+                logger.info(f"已发送插件状态: {len(status['loaded_plugins'])} 个已加载")
+            except Exception as e:
+                logger.error(f"发送插件状态失败: {e}")
+
+            try:
+                while True:
+                    data = await websocket.receive_json()
+                    command = data.get("command")
+
+                    if command == "reload":
+                        plugin_name = data.get("plugin_name")
+                        if not plugin_name:
+                            await websocket.send_json({"type": "error", "message": "缺少 plugin_name 参数"})
+                            continue
+
+                        # 执行插件重载
+                        success, message = await self._reload_plugin(plugin_name)
+                        await websocket.send_json(
+                            {
+                                "type": "reload_result",
+                                "success": success,
+                                "plugin_name": plugin_name,
+                                "message": message,
+                            }
+                        )
+
+                    elif command == "status":
+                        # 返回插件状态
+                        logger.info("返回插件状态")
+                        status = self._get_plugin_status()
+                        await websocket.send_json({"type": "status", **status})
+
+                    elif command == "ping":
+                        await websocket.send_json({"type": "pong"})
+
+                    elif command == "get_loaded_plugins":
+                        status = self._get_plugin_status()
+                        await websocket.send_json(
+                            {
+                                "type": "loaded_plugins",
+                                "loaded": status["loaded_plugins"],
+                                "failed": status["failed_plugins"],
+                            }
+                        )
+
+                    else:
+                        await websocket.send_json({"type": "error", "message": f"未知命令: {command}"})
+
+            except WebSocketDisconnect:
+                logger.info("开发模式客户端已断开")
+            except Exception as e:
+                logger.error(f"WebSocket 通信错误: {e}")
+            finally:
+                self.active_connections.discard(websocket)
+
+        @self.router.get("/status")
+        async def get_status():
+            """HTTP 状态查询端点
+
+            完整路径: http://{host}:{port}/plugin-api/dev_bridge/dev_bridge_router/status
+            """
+            return self._get_plugin_status()
+
+        @self.router.post("/reload/{plugin_name}")
+        async def reload_plugin(plugin_name: str):
+            """HTTP 重载端点
+
+            完整路径: http://{host}:{port}/plugin-api/dev_bridge/dev_bridge_router/reload/{plugin_name}
+            """
+            success, message = await self._reload_plugin(plugin_name)
+            return {"success": success, "plugin_name": plugin_name, "message": message}
+
+    async def _reload_plugin(self, plugin_name: str) -> tuple[bool, str]:
+        """重载插件
+
+        Args:
+            plugin_name: 插件名称（不是目录名）
+
+        Returns:
+            (成功, 消息)
+        """
+        from src.plugin_system.apis import (
+            plugin_manage_api,
+        )
+
+        try:
+            logger.info(f"开始重载插件: {plugin_name}")
+            success = await plugin_manage_api.reload_plugin(plugin_name)
+
+            # 广播重载成功消息
+            await self._broadcast({"type": "plugin_reloaded", "plugin_name": plugin_name, "success": success})
+
+            return True, f"插件 {plugin_name} 重载成功"
+        except Exception as e:
+            error_msg = f"插件重载失败: {e}"
+            logger.error(error_msg)
+
+            # 广播重载失败消息
+            await self._broadcast(
+                {"type": "plugin_reloaded", "plugin_name": plugin_name, "success": False, "error": str(e)}
+            )
+
+            return False, error_msg
+
+    def _get_plugin_status(self) -> dict:
+        """获取插件状态"""
+        # 使用 plugin_info_api 获取插件列表
+        from src.plugin_system.apis import (
+            plugin_info_api,
+        )
+
+        loaded_plugins = plugin_info_api.list_plugins("loaded")
+        failed_plugins = plugin_info_api.list_plugins("failed")
+
+        return {"loaded_plugins": loaded_plugins, "failed_plugins": failed_plugins}
+
+    async def _broadcast(self, message: dict) -> None:
+        """向所有连接的客户端广播消息"""
+        if not self.active_connections:
+            return
+
+        disconnected = set()
+        for connection in self.active_connections:
+            try:
+                await connection.send_json(message)
+            except Exception as e:
+                logger.warning(f"广播消息失败: {e}")
+                disconnected.add(connection)
+
+        # 清理断开的连接
+        self.active_connections -= disconnected
+
+
+@register_plugin
+class DevBridgePlugin(BasePlugin):
+    """开发模式桥接插件
+
+    这是一个特殊的插件，在开发模式下临时注入到主程序。
+    通过 WebSocket 与 mpdt dev 通信，提供插件重载等功能。
+    """
+
+    plugin_name = "dev_bridge"
+    enable_plugin = True
+    config_file_name = "config.toml"
+    dependencies: ClassVar = []
+    python_dependencies: ClassVar = []
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self._router_component: DevBridgeRouter | None = None
+        self._discovery_task: asyncio.Task | None = None
+
+    def get_plugin_components(self) -> list[tuple[ComponentInfo, type]]:
+        """注册路由组件"""
+        return [(DevBridgeRouter.get_router_info(), DevBridgeRouter)]
+
+    async def on_plugin_loaded(self):
+        """插件加载完成后启动发现服务器"""
+        from .discovery_server import start_discovery_server
+
+        # 获取主程序的 host 和 port
+        # 从 app_state 或配置中获取
+        try:
+            server = get_global_server()
+            main_host = server.host
+            main_port = server.port
+        except Exception:
+            main_host = "127.0.0.1"
+            main_port = 8000
+
+        # 启动发现服务器
+        self._discovery_task = asyncio.create_task(start_discovery_server(main_host, main_port))
+
+        logger.info(f"DevBridge 插件已加载，发现服务器: http://127.0.0.1:12318")
+        logger.info(f"WebSocket 端点: ws://{main_host}:{main_port}/plugin-api/dev_bridge/dev_bridge_router/ws")
+
+    async def on_plugin_unload(self):
+        """插件卸载时停止发现服务器"""
+        from .discovery_server import stop_discovery_server
+
+        if self._discovery_task:
+            self._discovery_task.cancel()
+            try:
+                await self._discovery_task
+            except asyncio.CancelledError:
+                pass
+
+        await stop_discovery_server()
+        logger.info("DevBridge 插件已卸载")

mpdt/templates/__init__.py

@@ -0,0 +1,165 @@
+"""
+组件模板索引
+
+此模块导出所有组件模板的获取函数。
+"""
+
+from datetime import datetime
+
+from mpdt.templates.action_template import get_action_template
+from mpdt.templates.adapter_template import get_adapter_template
+from mpdt.templates.chatter_template import get_chatter_template
+from mpdt.templates.event_template import get_event_handler_template
+from mpdt.templates.plus_command_template import get_plus_command_template
+from mpdt.templates.prompt_template import get_prompt_template
+from mpdt.templates.router_template import get_router_template
+from mpdt.templates.tool_template import get_tool_template
+
+# 导出所有模板获取函数
+__all__ = [
+    "get_action_template",
+    "get_tool_template",
+    "get_event_handler_template",
+    "get_adapter_template",
+    "get_prompt_template",
+    "get_plus_command_template",
+    "get_chatter_template",
+    "get_router_template",
+    "get_component_template",
+    "prepare_component_context",
+]
+
+
+def get_component_template(component_type: str) -> str:
+    """
+    根据组件类型获取对应的模板
+
+    Args:
+        component_type: 组件类型 (action, tool, event, adapter, prompt, plus_command, chatter, router)
+
+    Returns:
+        模板字符串
+
+    Raises:
+        ValueError: 不支持的组件类型
+    """
+    template_map = {
+        "action": get_action_template,
+        "tool": get_tool_template,
+        "event": get_event_handler_template,
+        "adapter": get_adapter_template,
+        "prompt": get_prompt_template,
+        "plus_command": get_plus_command_template,
+        "chatter": get_chatter_template,
+        "router": get_router_template,
+    }
+
+    if component_type not in template_map:
+        raise ValueError(
+            f"不支持的组件类型: {component_type}. "
+            f"支持的类型: {', '.join(template_map.keys())}"
+        )
+
+    return template_map[component_type]()
+
+
+def prepare_component_context(
+    component_type: str,
+    component_name: str,
+    plugin_name: str,
+    author: str = "",
+    description: str = "",
+    is_async: bool = False,
+) -> dict[str, str]:
+    """
+    准备组件模板上下文
+
+    Args:
+        component_type: 组件类型 (action, tool, event, adapter, prompt, plus_command,router,chatter)
+        component_name: 组件名称 (snake_case)
+        plugin_name: 插件名称
+        author: 作者
+        description: 描述
+        is_async: 是否异步
+
+    Returns:
+        模板上下文字典
+    """
+    from mpdt.utils.file_ops import to_pascal_case
+
+    # 转换为 PascalCase 并添加类型后缀
+    class_name = to_pascal_case(component_name)
+
+    # 根据组件类型添加合适的后缀
+    suffix_map = {
+        "action": "Action",
+        "tool": "Tool",
+        "event": "EventHandler",
+        "adapter": "Adapter",
+        "prompt": "Prompt",
+        "plus_command": "PlusCommand",
+        "chatter": "Chatter",
+        "router": "Router",
+    }
+
+    suffix = suffix_map.get(component_type, "")
+    if suffix and not class_name.endswith(suffix):
+        class_name = f"{class_name}{suffix}"
+
+    date = datetime.now().strftime("%Y-%m-%d")
+
+    # 基础上下文
+    context = {
+        "component_name": component_name,
+        "class_name": class_name,
+        "plugin_name": plugin_name,
+        "author": author,
+        "description": description or f"{class_name} 组件",
+        "date": date,
+        "async_keyword": "async " if is_async else "",
+        "await_keyword": "await " if is_async else "",
+        "component_type": component_type + "s",  # actions, tools, etc.
+        "module_name": component_name,
+        "method_name": _get_method_name(component_type),
+    }
+
+    # 特定组件类型的额外字段
+    if component_type == "plus_command":
+        context["command_name"] = component_name
+    elif component_type == "tool":
+        context["tool_name"] = component_name
+    elif component_type == "event":
+        context["event_type"] = component_name.replace("_handler", "").replace("_event", "")
+    elif component_type == "adapter":
+        context["adapter_name"] = component_name
+    elif component_type == "prompt":
+        context["prompt_name"] = component_name
+    elif component_type == "chatter":
+        context["chatter_name"] = component_name
+    elif component_type == "router":
+        context["router_name"] = component_name
+
+    return context
+
+
+def _get_method_name(component_type: str) -> str:
+    """
+    根据组件类型获取主要方法名
+
+    Args:
+        component_type: 组件类型
+
+    Returns:
+        方法名
+    """
+    method_map = {
+        "action": "execute",
+        "plus_command": "execute",
+        "tool": "run",
+        "event": "handle",
+        "adapter": "connect",
+        "prompt": "build",
+        "chatter": "chat",
+        "router": "route",
+    }
+    return method_map.get(component_type, "execute")

mpdt/templates/action_template.py

@@ -0,0 +1,102 @@
+"""
+Action 组件模板
+"""
+
+ACTION_TEMPLATE = '''"""
+{description}
+
+Created by: {author}
+Created at: {date}
+"""
+
+from src.common.logger import get_logger
+from src.plugin_system import BaseAction, ActionActivationType, ChatMode
+
+logger = get_logger(__name__)
+
+
+class {class_name}(BaseAction):
+    """
+    {description}
+
+    Action 组件用于执行聊天中的具体动作任务。
+    """
+
+    # Action 元数据
+    action_name: str = "{component_name}"
+    action_description: str = "{description}"
+
+    # 激活配置
+    mode_enable: list[ChatMode] = [ChatMode.FOCUS, ChatMode.NORMAL]  # 支持的聊天模式
+    parallel_action: bool = False  # 是否允许与其他 Action 并行执行
+
+    # 专注模式激活配置
+    focus_activation_type: ActionActivationType = ActionActivationType.KEYWORD
+    # 普通模式激活配置
+    normal_activation_type: ActionActivationType = ActionActivationType.LLM_JUDGE
+
+    # 激活条件
+    activation_keywords: list[str] = ["关键词1", "关键词2"]  # 关键词激活时使用
+    keyword_case_sensitive: bool = False  # 关键词是否区分大小写
+
+    # LLM 判断激活的提示词
+    llm_judge_prompt: str = """
+判断用户是否需要执行某个特定操作。
+如果需要，返回 true，否则返回 false。
+"""
+
+    async def go_activate(self, llm_judge_model=None) -> bool:
+        """
+        自定义激活逻辑（推荐方式）
+
+        可以组合使用以下工具函数：
+        - await self._keyword_match(["关键词"])  # 关键词匹配
+        - await self._random_activation(0.3)  # 随机激活（30%概率）
+        - await self._llm_judge_activation(prompt, llm_judge_model)  # LLM判断
+
+        Returns:
+            是否激活此 Action
+        """
+        # 示例：关键词匹配
+        return await self._keyword_match(self.activation_keywords, self.keyword_case_sensitive)
+
+    async def execute(self) -> tuple[bool, str]:
+        """
+        执行 Action 的主要逻辑
+
+        可以使用以下方法：
+        - await self.send_text("文本内容")  # 发送文本消息
+        - await self.send_image(image_base64)  # 发送图片
+        - await self.send_command("command_name", args)  # 调用命令
+        - await self.call_action("action_name", data)  # 调用其他 Action
+        - await self.wait_for_new_message(timeout)  # 等待用户回复
+
+        Returns:
+            (是否成功, 结果消息)
+        """
+        try:
+            logger.info(f"执行 Action: {{self.action_name}}")
+
+            # TODO: 实现 Action 的核心逻辑
+
+            # 示例：发送消息
+            await self.send_text("Action 执行成功！")
+
+            # 存储 Action 信息到上下文
+            await self.store_action_info(
+                action_build_into_prompt=True,
+                action_prompt_display=f"执行了 {{self.action_name}}",
+                action_done=True
+            )
+
+            return True, "执行成功"
+
+        except Exception as e:
+            logger.error(f"Action 执行失败: {{e}}")
+            return False, f"执行失败: {{e}}"
+'''
+
+
+def get_action_template() -> str:
+    """获取 Action 组件模板"""
+    return ACTION_TEMPLATE

mpdt/templates/adapter_template.py

@@ -0,0 +1,129 @@
+"""
+Adapter 组件模板
+"""
+
+ADAPTER_TEMPLATE = '''"""
+{description}
+
+Created by: {author}
+Created at: {date}
+"""
+
+from typing import Any
+
+from mofox_wire import MessageEnvelope
+from src.common.logger import get_logger
+from src.plugin_system import BaseAdapter
+
+logger = get_logger(__name__)
+
+
+class {class_name}(BaseAdapter):
+    """
+    {description}
+
+    Adapter 组件用于连接不同的平台或服务。
+
+    支持的场景：
+    - QQ/微信等聊天平台
+    - Discord/Telegram 等国际平台
+    - 自定义 API 服务
+    - WebSocket/HTTP 协议适配
+    """
+
+    # Adapter 元数据
+    adapter_name: str = "{adapter_name}"
+    adapter_version: str = "1.0.0"
+    adapter_author: str = "{author}"
+    adapter_description: str = "{description}"
+
+    # 是否在子进程中运行
+    run_in_subprocess: bool = False
+    # 子进程启动脚本路径（相对于插件目录）
+    subprocess_entry: str | None = None
+
+    async def from_platform_message(self, raw: Any) -> MessageEnvelope:
+        """
+        将平台原始消息转换为标准 MessageEnvelope 格式
+
+        Args:
+            raw: 平台原始消息对象
+
+        Returns:
+            MessageEnvelope: 标准消息信封
+        """
+        try:
+            logger.debug(f"转换平台消息: {{raw}}")
+
+            # TODO: 解析平台消息并转换为 MessageEnvelope
+            # 示例：
+            # message_id = raw.get("message_id")
+            # user_id = raw.get("user_id")
+            # content = raw.get("content")
+            # timestamp = raw.get("timestamp")
+            #
+            # return MessageEnvelope(
+            #     message_id=message_id,
+            #     user_id=user_id,
+            #     content=content,
+            #     timestamp=timestamp,
+            #     platform="your_platform"
+            # )
+
+            raise NotImplementedError("需要实现 from_platform_message 方法")
+
+        except Exception as e:
+            logger.error(f"转换消息失败: {{e}}")
+            raise
+
+    async def _send_platform_message(self, envelope: MessageEnvelope) -> None:
+        """
+        发送消息到平台
+
+        Args:
+            envelope: 要发送的消息信封
+        """
+        try:
+            logger.info(f"发送消息: {{envelope.message_id}}")
+
+            # TODO: 实现发送消息逻辑
+            # 将 MessageEnvelope 转换为平台格式并发送
+            # 示例：
+            # platform_message = {{
+            #     "target_id": envelope.target_id,
+            #     "content": envelope.content,
+            #     "message_type": envelope.message_type
+            # }}
+            # await self.platform_api.send(platform_message)
+
+            raise NotImplementedError("需要实现 _send_platform_message 方法")
+
+        except Exception as e:
+            logger.error(f"发送消息失败: {{e}}")
+            raise
+
+    async def on_adapter_loaded(self) -> None:
+        """
+        适配器加载时的钩子
+        可以在这里执行初始化逻辑
+        """
+        logger.info(f"{{self.adapter_name}} 适配器加载完成")
+
+        # TODO: 初始化逻辑
+        # 例如：建立连接、加载配置、启动后台任务等
+
+    async def on_adapter_unloaded(self) -> None:
+        """
+        适配器卸载时的钩子
+        可以在这里执行清理逻辑
+        """
+        logger.info(f"{{self.adapter_name}} 适配器卸载")
+
+        # TODO: 清理逻辑
+        # 例如：关闭连接、保存状态、停止后台任务等
+'''
+
+
+def get_adapter_template() -> str:
+    """获取 Adapter 组件模板"""
+    return ADAPTER_TEMPLATE