调整目录结构，将框架内容放到base里面

base/plugin_common/plugin_manager.py

@@ -0,0 +1,585 @@
+import importlib
+import inspect
+import os
+import sys
+from typing import Dict, List, Any, Optional, Tuple
+
+from loguru import logger
+
+from base.plugin_common.plugin_interface import PluginInterface, PluginStatus
+from base.plugin_common.message_plugin_interface import MessagePluginInterface
+from base.plugin_common.scheduled_plugin_interface import ScheduledPluginInterface
+from base.plugin_common.plugin_registry import PluginRegistry
+from base.plugin_common.event_system import EventSystem, EventType
+from wechat_ipad import WechatAPIClient
+
+
+class PluginManager:
+    """插件管理器，负责加载、卸载、启动、停止插件"""
+
+    # 单例实例
+    _instance = None
+
+    @classmethod
+    def get_instance(cls, plugin_dir=None):
+        """获取单例实例
+        
+        Args:
+            plugin_dir: 插件目录，如果已有实例则忽略此参数
+            
+        Returns:
+            PluginManager实例
+        """
+        if cls._instance is None:
+            cls._instance = cls(plugin_dir=plugin_dir or "plugins")
+        return cls._instance
+
+    def __new__(cls, *args, **kwargs):
+        """实现单例模式"""
+        if cls._instance is None:
+            cls._instance = super(PluginManager, cls).__new__(cls)
+            cls._instance._initialized = False
+        return cls._instance
+
+    def __init__(self, plugin_dir: str = "plugins"):
+        """
+        初始化插件管理器
+        
+        Args:
+            plugin_dir: 插件目录
+        """
+        self.plugin_dir = plugin_dir
+        self.plugins: Dict[str, PluginInterface] = {}  # 插件实例字典，键为display_name
+        self.plugin_modules = {}  # 插件模块字典，键为module_name
+        self.module_to_display = {}  # 模块名到显示名的映射
+        self.system_context = {}  # 系统上下文
+
+        self.LOG = logger
+        # 确保插件目录存在
+        if not os.path.exists(self.plugin_dir):
+            os.makedirs(self.plugin_dir)
+
+        # 将插件目录添加到Python路径
+        if self.plugin_dir not in sys.path:
+            sys.path.insert(0, self.plugin_dir)
+
+    def set_system_context(self, context: Dict[str, Any]):
+        """
+        设置系统上下文
+        
+        Args:
+            context: 系统上下文
+        """
+        self.system_context = context
+
+    def discover_plugins(self) -> List[str]:
+        """
+        发现可用插件
+        
+        Returns:
+            插件模块名称列表(module_name)
+        """
+        module_names = []
+
+        # 遍历插件目录
+        for item in os.listdir(self.plugin_dir):
+            if os.path.isdir(os.path.join(self.plugin_dir, item)) and not item.startswith("__"):
+                # 检查是否有main.py文件
+                if os.path.exists(os.path.join(self.plugin_dir, item, "main.py")):
+                    module_names.append(item)
+            elif item.endswith(".py") and not item.startswith("__"):
+                # 单文件插件
+                module_names.append(item[:-3])
+        self.LOG.debug(f"PluginManager：发现插件模块: {module_names}")
+        return module_names
+
+    def load_all_plugins(self) -> Dict[str, PluginInterface]:
+        """
+        加载所有插件
+        
+        Returns:
+            插件实例字典，键为display_name
+        """
+        module_names = self.discover_plugins()
+        loaded_modules = []
+        failed_modules = []
+
+        # 记录开始加载的插件列表
+        self.LOG.debug(f"PluginManager：开始加载插件列表: {module_names}")
+
+        for module_name in module_names:
+            try:
+                plugin = self.load_plugin(module_name)
+                if plugin:
+                    loaded_modules.append(module_name)
+                    # 自动启动插件
+                    self.start_plugin(plugin.name)
+                else:
+                    failed_modules.append(module_name)
+            except Exception as e:
+                self.LOG.error(f"PluginManager：加载插件模块 {module_name} 时发生错误: {str(e)}", exc_info=True)
+                failed_modules.append(module_name)
+
+        # 验证所有已加载插件的模块映射
+        for display_name, plugin in self.plugins.items():
+            try:
+                # 尝试从类模块路径获取模块名
+                module_name = self._get_module_name_from_plugin(plugin)
+                if module_name and module_name not in self.module_to_display:
+                    self.module_to_display[module_name] = display_name
+                    self.LOG.debug(f"PluginManager：补充缺失的模块映射 {module_name} -> {display_name}")
+            except Exception as e:
+                self.LOG.warning(f"PluginManager：获取插件 {display_name} 的模块名时出错: {e}")
+                # 使用插件显示名称作为备选模块名
+                folder_name = display_name.lower().replace(' ', '_')
+                if folder_name not in self.module_to_display:
+                    self.module_to_display[folder_name] = display_name
+                    self.LOG.debug(f"PluginManager：使用目录名作为模块映射 {folder_name} -> {display_name}")
+
+        # 检查是否有重复或无效的映射
+        invalid_mappings = []
+        for module_name, display_name in self.module_to_display.items():
+            if display_name not in self.plugins:
+                invalid_mappings.append(module_name)
+                self.LOG.warning(f"PluginManager：发现无效的模块映射 {module_name} -> {display_name}")
+
+        # 清理无效的映射
+        for module_name in invalid_mappings:
+            del self.module_to_display[module_name]
+            self.LOG.debug(f"PluginManager：清理无效的模块映射 {module_name}")
+
+        # 记录最终状态
+        self.LOG.debug(f"PluginManager：加载成功的插件模块: {loaded_modules}")
+        if failed_modules:
+            self.LOG.warning(f"PluginManager：加载失败的插件模块: {failed_modules}")
+        self.LOG.debug(f"PluginManager：当前已加载的插件实例: {list(self.plugins.keys())}")
+        self.LOG.debug(f"PluginManager：最终的模块映射关系: {self.module_to_display}")
+
+        return self.plugins
+
+    def _get_module_name_from_plugin(self, plugin: PluginInterface) -> Optional[str]:
+        """
+        从插件实例获取模块名
+        
+        Args:
+            plugin: 插件实例
+            
+        Returns:
+            模块名，获取失败返回None
+        """
+        try:
+            # 获取完整模块路径
+            full_module = plugin.__class__.__module__
+            module_parts = full_module.split('.')
+
+            # 处理不同的模块路径情况
+            if len(module_parts) >= 2 and module_parts[0] == 'plugins':
+                # 对于目录插件，模块名在第二个位置
+                return module_parts[1]
+            elif len(module_parts) >= 2:
+                # 其他情况，取倒数第二个
+                return module_parts[-2]
+            else:
+                # 单文件插件，直接返回
+                return full_module
+        except (IndexError, AttributeError) as e:
+            self.LOG.warning(f"获取插件 {plugin.name} 的模块名时出错: {e}")
+            return None
+
+    def load_plugin(self, module_name: str) -> Optional[PluginInterface]:
+        """
+        加载插件
+        
+        Args:
+            module_name: 插件模块名
+            
+        Returns:
+            插件实例，加载失败返回None
+        """
+        try:
+            # 检查是否已有同名模块的插件加载
+            for display_name, plugin in self.plugins.items():
+                try:
+                    plugin_module_name = self._get_module_name_from_plugin(plugin)
+                    if plugin_module_name == module_name:
+                        self.LOG.debug(f"PluginManager：插件模块 {module_name} 已加载为 {display_name}")
+                        # 确保模块名到显示名的映射存在
+                        if module_name not in self.module_to_display:
+                            self.module_to_display[module_name] = display_name
+                            self.LOG.debug(f"PluginManager：添加缺失的模块映射 {module_name} -> {display_name}")
+                        return plugin
+                except Exception as e:
+                    self.LOG.warning(f"获取插件 {display_name} 的模块名时出错: {e}")
+                    continue
+
+            # 确定插件路径和模块路径
+            plugin_path = os.path.join(self.plugin_dir, module_name)
+
+            # 加载模块
+            if os.path.isdir(plugin_path) and os.path.exists(os.path.join(plugin_path, "main.py")):
+                # 目录插件，从main.py加载
+                module_path = f"plugins.{module_name}.main"
+                try:
+                    module = importlib.import_module(module_path)
+                    self.plugin_modules[module_name] = module
+                except ImportError as e:
+                    self.LOG.error(f"PluginManager：导入插件模块 {module_path} 失败: {e}")
+                    return None
+            else:
+                # 单文件插件
+                plugin_path = self.plugin_dir
+                try:
+                    module = importlib.import_module(module_name)
+                    self.plugin_modules[module_name] = module
+                except ImportError as e:
+                    self.LOG.error(f"PluginManager：导入单文件插件 {module_name} 失败: {e}")
+                    return None
+
+            # 查找插件类
+            plugin_class = None
+            for name, obj in inspect.getmembers(module):
+                if (inspect.isclass(obj) and
+                        issubclass(obj, PluginInterface) and
+                        obj != PluginInterface and
+                        obj != MessagePluginInterface and
+                        obj != ScheduledPluginInterface):
+                    plugin_class = obj
+                    break
+
+            # 如果没有找到插件类，尝试查找get_plugin函数
+            if plugin_class is None:
+                get_plugin_func = getattr(module, "get_plugin", None)
+                if callable(get_plugin_func):
+                    plugin = get_plugin_func()
+                    if isinstance(plugin, PluginInterface):
+                        # 设置插件路径
+                        plugin.set_plugin_path(plugin_path)
+
+                        # 加载插件配置
+                        if not plugin.load_config():
+                            self.LOG.error(f"PluginManager：插件模块 {module_name} 加载配置失败")
+                            return None
+
+                        # 初始化插件
+                        if not plugin.initialize(self.system_context):
+                            self.LOG.error(f"PluginManager：插件模块 {module_name} 初始化失败")
+                            return None
+
+                        # 注册插件
+                        PluginRegistry().register(plugin)
+
+                        # 获取显示名称
+                        display_name = plugin.name
+
+                        # 存储插件实例
+                        self.plugins[display_name] = plugin
+
+                        # 添加模块名到显示名的映射
+                        self.module_to_display[module_name] = display_name
+                        # self.LOG.info(f"PluginManager：添加模块映射 {module_name} -> {display_name}")
+
+                        # 发布插件加载事件
+                        EventSystem().publish(EventType.PLUGIN_LOADED, {"plugin": plugin})
+
+                        return plugin
+                    else:
+                        self.LOG.error(f"PluginManager：插件模块 {module_name} 的 get_plugin() 返回的不是有效的插件实例")
+                else:
+                    self.LOG.error(f"PluginManager：插件模块 {module_name} 中未找到有效的插件类或 get_plugin 函数")
+                return None
+
+            # 实例化插件
+            plugin = plugin_class()
+            plugin.status = PluginStatus.LOADED
+
+            # 设置插件路径
+            plugin.set_plugin_path(plugin_path)
+
+            # 在load_plugin方法中，找到加载配置后的位置（约在第298行）
+            # 加载插件配置
+            if not plugin.load_config():
+                self.LOG.error(f"PluginManager：插件模块 {module_name} 加载配置失败")
+                return None
+
+            # 修改检查enable状态的代码：遍历所有配置节点
+            for section in plugin._config.values():
+                if isinstance(section, dict) and not section.get("enable", True):
+                    self.LOG.debug(f"PluginManager：插件 {module_name} 已禁用，跳过加载")
+                    return None
+
+            # 初始化插件
+            if not plugin.initialize(self.system_context):
+                self.LOG.error(f"PluginManager：插件模块 {module_name} 初始化失败")
+                return None
+
+            # 注册插件
+            PluginRegistry().register(plugin)
+
+            # 获取显示名称
+            display_name = plugin.name
+
+            # 存储插件实例
+            self.plugins[display_name] = plugin
+
+            # 添加模块名到显示名的映射
+            self.module_to_display[module_name] = display_name
+            # self.LOG.info(f"PluginManager：添加模块映射 {module_name} -> {display_name}")
+
+            # 发布插件加载事件
+            EventSystem().publish(EventType.PLUGIN_LOADED, {"plugin": plugin})
+
+            return plugin
+
+        except Exception as e:
+            self.LOG.error(f"PluginManager：加载插件模块 {module_name} 失败: {e}", exc_info=True)
+            return None
+
+    def unload_plugin(self, name: str) -> bool:
+        """
+        卸载插件
+        
+        Args:
+            name: 插件名称（可以是模块名或显示名称）
+            
+        Returns:
+            卸载是否成功
+        """
+        # 查找插件
+        display_name, plugin = self.find_plugin_by_name(name)
+
+        if not plugin:
+            self.LOG.debug(f"PluginManager：插件 {name} 未加载")
+            return False
+
+        # 停止插件
+        if plugin.status == PluginStatus.RUNNING:
+            if not plugin.stop():
+                self.LOG.debug(f"PluginManager：停止插件 {display_name} 失败")
+                return False
+            plugin.status = PluginStatus.STOPPED  # 确保状态更新
+
+        # 清理插件资源
+        if not plugin.cleanup():
+            self.LOG.debug(f"PluginManager：清理插件 {display_name} 资源失败")
+            return False
+
+        # 设置状态为未加载
+        plugin.status = PluginStatus.UNLOADED
+
+        # 注销插件
+        PluginRegistry().unregister(display_name)
+
+        # 获取模块名，用于清理映射
+        module_name = self._get_module_name_from_plugin(plugin)
+        if module_name and module_name in self.module_to_display:
+            del self.module_to_display[module_name]
+            self.LOG.debug(f"PluginManager：清理模块映射 {module_name} -> {display_name}")
+
+        # 移除插件实例
+        del self.plugins[display_name]
+
+        # 发布插件卸载事件
+        EventSystem().publish(EventType.PLUGIN_UNLOADED, {"plugin_name": display_name})
+
+        return True
+
+    def reload_plugin(self, name: str) -> Optional[PluginInterface]:
+        """
+        重新加载插件
+        
+        Args:
+            name: 插件名称（可以是模块名或显示名称）
+            
+        Returns:
+            插件实例，重新加载失败返回None
+        """
+        # 查找插件
+        display_name, plugin = self.find_plugin_by_name(name)
+
+        if not plugin:
+            self.LOG.debug(f"PluginManager：插件 {name} 未加载，无法重载")
+            return None
+
+        # 记录原插件状态和模块名
+        was_running = plugin.status == PluginStatus.RUNNING
+        module_name = self._get_module_name_from_plugin(plugin)
+
+        if not module_name:
+            self.LOG.error(f"无法获取插件 {display_name} 的模块名，重载失败")
+            return None
+
+        # 卸载插件
+        if not self.unload_plugin(display_name):
+            self.LOG.debug(f"卸载插件 {display_name} 失败，无法重载")
+            return None
+
+        # 重新导入模块
+        if module_name in self.plugin_modules:
+            try:
+                importlib.reload(self.plugin_modules[module_name])
+            except Exception as e:
+                self.LOG.debug(f"重新导入插件模块 {module_name} 失败: {e}")
+                return None
+
+        # 加载插件
+        plugin = self.load_plugin(module_name)
+
+        # 如果原来是运行状态，则重新启动
+        if plugin and was_running:
+            self.start_plugin(plugin.name)
+
+        return plugin
+
+    def start_plugin(self, name: str) -> bool:
+        """
+        启动插件
+        
+        Args:
+            name: 插件名称（可以是模块名或显示名称）
+            
+        Returns:
+            启动是否成功
+        """
+        # 查找插件
+        display_name, plugin = self.find_plugin_by_name(name)
+
+        if not plugin:
+            self.LOG.debug(f"PluginManager：插件 {name} 未加载")
+            return False
+
+        if plugin.status == PluginStatus.RUNNING:
+            self.LOG.debug(f"PluginManager：插件 {display_name} 已经在运行")
+            return True
+
+        if plugin.start():
+            plugin.status = PluginStatus.RUNNING
+            self.LOG.debug(f"PluginManager：插件 {display_name} 状态变更为在运行")
+            return True
+        else:
+            plugin.status = PluginStatus.ERROR
+            self.LOG.debug(f"PluginManager：插件 {display_name} 状态变更为异常")
+            return False
+
+    def stop_plugin(self, name: str) -> bool:
+        """
+        停止插件
+        
+        Args:
+            name: 插件名称（可以是模块名或显示名称）
+            
+        Returns:
+            停止是否成功
+        """
+        # 查找插件
+        display_name, plugin = self.find_plugin_by_name(name)
+
+        if not plugin:
+            self.LOG.debug(f"插件 {name} 未加载")
+            return False
+
+        if plugin.status != PluginStatus.RUNNING:
+            self.LOG.debug(f"插件 {display_name} 未在运行")
+            return True
+
+        if plugin.stop():
+            plugin.status = PluginStatus.STOPPED
+            self.LOG.debug(f"插件 {display_name} 状态变更为已停止")
+            return True
+        else:
+            plugin.status = PluginStatus.ERROR
+            self.LOG.debug(f"插件 {display_name} 状态变更为异常")
+            return False
+
+    def shutdown_plugins(self) -> bool:
+        """
+        卸载所有插件
+        
+        Returns:
+            是否全部成功卸载
+        """
+        success = True
+        # 创建插件名称的副本，因为在卸载过程中会修改self.plugins字典
+        display_names = list(self.plugins.keys())
+
+        for display_name in display_names:
+            if not self.unload_plugin(display_name):
+                self.LOG.error(f"卸载插件 {display_name} 失败")
+                success = False
+
+        # 清空插件模块字典
+        self.plugin_modules.clear()
+        self.module_to_display.clear()
+
+        # 确保插件字典为空
+        if self.plugins:
+            self.LOG.warning(f"插件卸载后仍有 {len(self.plugins)} 个插件残留")
+            success = False
+
+        return success
+
+    def find_plugin_by_name(self, name: str) -> Tuple[Optional[str], Optional[PluginInterface]]:
+        """
+        根据插件名称或模块名查找插件
+
+        Args:
+            name: 插件名称或模块名
+
+        Returns:
+            (插件显示名称, 插件实例) 元组，未找到返回 (None, None)
+        """
+        # 直接通过显示名称查找
+        if name in self.plugins:
+            return name, self.plugins[name]
+
+        # 通过模块名查找
+        if name in self.module_to_display:
+            display_name = self.module_to_display[name]
+            return display_name, self.plugins.get(display_name)
+
+        # 遍历所有插件查找匹配的模块名
+        for display_name, plugin in self.plugins.items():
+            try:
+                module_name = self._get_module_name_from_plugin(plugin)
+                if module_name and module_name == name:
+                    # 顺便更新映射
+                    if module_name not in self.module_to_display:
+                        self.module_to_display[module_name] = display_name
+                        self.LOG.debug(f"PluginManager：添加缺失的模块映射 {module_name} -> {display_name}")
+                    return display_name, plugin
+
+                # 不区分大小写比较
+                if module_name and module_name.lower() == name.lower():
+                    if module_name not in self.module_to_display:
+                        self.module_to_display[module_name] = display_name
+                    return display_name, plugin
+
+                # 检查名称是否包含在模块名中（不区分大小写）
+                if module_name and name.lower() in module_name.lower():
+                    return display_name, plugin
+
+                # 检查模块名是否包含在名称中（不区分大小写）
+                if module_name and module_name.lower() in name.lower():
+                    return display_name, plugin
+
+                # 检查名称是否包含在显示名称中（不区分大小写）
+                if name.lower() in display_name.lower():
+                    return display_name, plugin
+            except Exception:
+                continue
+
+        # 记录未找到插件的详细信息，帮助调试
+        self.LOG.warning(f"未找到插件: {name}，当前已加载插件: {list(self.plugins.keys())}")
+        self.LOG.warning(f"模块映射: {self.module_to_display}")
+
+        return None, None
+
+    def inject_bot(self, bot: WechatAPIClient):
+        self.system_context["bot"] = bot
+        for name, plugin in self.plugins.items():
+            # self.LOG.debug(f"plugin name{name}, plugin: {plugin}")
+            if hasattr(plugin, "set_bot"):
+                try:
+                    plugin.set_bot(bot)
+                    self.LOG.debug(f"已成功注入 bot 到插件 {name}")
+                except Exception as e:
+                    self.LOG.error(f"注入 bot 到插件 {name} 失败: {e}")