ErisPulse 2.1.14.dev1__py3-none-any.whl → 2.1.15__py3-none-any.whl

ErisPulse/__main__.py

@@ -95,7 +95,7 @@ class PackageManager:
     """
     REMOTE_SOURCES = [
         "https://erisdev.com/packages.json",
-        "https://raw.githubusercontent.com/ErisPulse/ErisPulse-ModuleRepo/main/packages.json"
+        "https://raw.githubusercontent.com/ErisPulse/ErisPulse/main/packages.json"
     ]
     
     CACHE_EXPIRY = 3600  # 1小时缓存
@@ -256,13 +256,76 @@ class PackageManager:
         except Exception:
             return False
     
-    def _run_pip_command(self, args: List[str], description: str) -> bool:
+    def _normalize_name(self, name: str) -> str:
         """
-        执行pip命令
+        标准化包名，统一转为小写以实现大小写不敏感比较
+        
+        :param name: 原始名称
+        :return: 标准化后的名称
+        """
+        return name.lower().strip()
+    
+    async def _find_package_by_alias(self, alias: str) -> Optional[str]:
+        """
+        通过别名查找实际包名（大小写不敏感）
+        
+        :param alias: 包别名
+        :return: 实际包名，未找到返回None
+        """
+        normalized_alias = self._normalize_name(alias)
+        remote_packages = await self.get_remote_packages()
+        
+        # 检查模块
+        for name, info in remote_packages["modules"].items():
+            if self._normalize_name(name) == normalized_alias:
+                return info["package"]
+                
+        # 检查适配器
+        for name, info in remote_packages["adapters"].items():
+            if self._normalize_name(name) == normalized_alias:
+                return info["package"]
+                
+        # 检查CLI扩展
+        for name, info in remote_packages.get("cli_extensions", {}).items():
+            if self._normalize_name(name) == normalized_alias:
+                return info["package"]
+                
+        return None
+    
+    def _find_installed_package_by_name(self, name: str) -> Optional[str]:
+        """
+        在已安装包中查找实际包名（大小写不敏感）
+        
+        :param name: 包名或别名
+        :return: 实际包名，未找到返回None
+        """
+        normalized_name = self._normalize_name(name)
+        installed = self.get_installed_packages()
+        
+        # 在已安装的模块中查找
+        for module_info in installed["modules"].values():
+            if self._normalize_name(module_info["package"]) == normalized_name:
+                return module_info["package"]
+                    
+        # 在已安装的适配器中查找
+        for adapter_info in installed["adapters"].values():
+            if self._normalize_name(adapter_info["package"]) == normalized_name:
+                return adapter_info["package"]
+                    
+        # 在已安装的CLI扩展中查找
+        for cli_info in installed["cli_extensions"].values():
+            if self._normalize_name(cli_info["package"]) == normalized_name:
+                return cli_info["package"]
+                
+        return None
+
+    def _run_pip_command_with_output(self, args: List[str], description: str) -> Tuple[bool, str, str]:
+        """
+        执行pip命令并捕获输出
         
         :param args: pip命令参数列表
         :param description: 进度条描述
-        :return: 命令是否成功执行
+        :return: (是否成功, 标准输出, 标准错误)
         """
         with Progress(
             TextColumn(f"[progress.description]{description}"),
@@ -276,61 +339,266 @@ class PackageManager:
                     [sys.executable, "-m", "pip"] + args,
                     stdout=subprocess.PIPE,
                     stderr=subprocess.PIPE,
-                    universal_newlines=True
+                    universal_newlines=True,
+                    bufsize=1  # 行缓冲
                 )
                 
-                while True:
-                    output = process.stdout.readline()
-                    if output == '' and process.poll() is not None:
-                        break
-                    if output:
-                        progress.update(task, advance=1)
-                        
-                return process.returncode == 0
+                stdout_lines = []
+                stderr_lines = []
+                
+                # 使用超时机制避免永久阻塞
+                import threading
+                import queue
+                
+                def read_output(pipe, lines_list):
+                    try:
+                        for line in iter(pipe.readline, ''):
+                            lines_list.append(line)
+                            progress.update(task, advance=5)  # 每行增加进度
+                        pipe.close()
+                    except Exception:
+                        pass
+                
+                stdout_thread = threading.Thread(target=read_output, args=(process.stdout, stdout_lines))
+                stderr_thread = threading.Thread(target=read_output, args=(process.stderr, stderr_lines))
+                
+                stdout_thread.start()
+                stderr_thread.start()
+                
+                # 等待进程结束，最多等待5分钟
+                try:
+                    process.wait(timeout=300)
+                except subprocess.TimeoutExpired:
+                    process.kill()
+                    process.wait()
+                    console.print("[warning]命令执行超时，已强制终止[/]")
+                    return False, "", "命令执行超时"
+                
+                stdout_thread.join(timeout=10)
+                stderr_thread.join(timeout=10)
+                
+                stdout = ''.join(stdout_lines)
+                stderr = ''.join(stderr_lines)
+                
+                return process.returncode == 0, stdout, stderr
             except subprocess.CalledProcessError as e:
                 console.print(f"[error]命令执行失败: {e}[/]")
-                return False
-    
-    def install_package(self, package_name: str, upgrade: bool = False) -> bool:
+                return False, "", str(e)
+            except Exception as e:
+                console.print(f"[error]执行过程中发生异常: {e}[/]")
+                return False, "", str(e)
+
+    def _compare_versions(self, version1: str, version2: str) -> int:
+        """
+        比较两个版本号
+        
+        :param version1: 版本号1
+        :param version2: 版本号2
+        :return: 1 if version1 > version2, -1 if version1 < version2, 0 if equal
+        """
+        from packaging import version as comparison
+        try:
+            v1 = comparison.parse(version1)
+            v2 = comparison.parse(version2)
+            if v1 > v2:
+                return 1
+            elif v1 < v2:
+                return -1
+            else:
+                return 0
+        except comparison.InvalidVersion:
+            # 如果无法解析，使用字符串比较作为后备
+            if version1 > version2:
+                return 1
+            elif version1 < version2:
+                return -1
+            else:
+                return 0
+
+    def _check_sdk_compatibility(self, min_sdk_version: str) -> Tuple[bool, str]:
+        """
+        检查SDK版本兼容性
+        
+        :param min_sdk_version: 所需的最小SDK版本
+        :return: (是否兼容, 当前版本信息)
+        """
+        try:
+            from ErisPulse import __version__
+            current_version = __version__
+        except ImportError:
+            current_version = "unknown"
+        
+        if current_version == "unknown":
+            return True, "无法确定当前SDK版本"
+        
+        try:
+            compatibility = self._compare_versions(current_version, min_sdk_version)
+            if compatibility >= 0:
+                return True, f"当前SDK版本 {current_version} 满足最低要求 {min_sdk_version}"
+            else:
+                return False, f"当前SDK版本 {current_version} 低于最低要求 {min_sdk_version}"
+        except Exception:
+            return True, "无法验证SDK版本兼容性"
+
+    async def _get_package_info(self, package_name: str) -> Optional[Dict[str, Any]]:
+        """
+        获取包的详细信息（包括min_sdk_version等）
+        
+        :param package_name: 包名或别名
+        :return: 包信息字典
+        """
+        # 首先尝试通过别名查找
+        normalized_name = self._normalize_name(package_name)
+        remote_packages = await self.get_remote_packages()
+        
+        # 检查模块
+        for name, info in remote_packages["modules"].items():
+            if self._normalize_name(name) == normalized_name:
+                return info
+        
+        # 检查适配器
+        for name, info in remote_packages["adapters"].items():
+            if self._normalize_name(name) == normalized_name:
+                return info
+        
+        # 检查CLI扩展
+        for name, info in remote_packages.get("cli_extensions", {}).items():
+            if self._normalize_name(name) == normalized_name:
+                return info
+        
+        return None
+
+    def install_package(self, package_names: List[str], upgrade: bool = False, pre: bool = False) -> bool:
         """
-        安装指定包
+        安装指定包（支持多个包）
         
-        :param package_name: 要安装的包名
+        :param package_names: 要安装的包名或别名列表
         :param upgrade: 是否升级已安装的包
+        :param pre: 是否包含预发布版本
         :return: 安装是否成功
         """
-        cmd = ["install"]
-        if upgrade:
-            cmd.append("--upgrade")
-        cmd.append(package_name)
+        all_success = True
         
-        success = self._run_pip_command(cmd, f"安装 {package_name}")
-        
-        if success:
-            console.print(f"[success]包 {package_name} 安装成功[/]")
-        else:
-            console.print(f"[error]包 {package_name} 安装失败[/]")
+        for package_name in package_names:
+            # 首先尝试通过别名查找实际包名
+            actual_package = asyncio.run(self._find_package_by_alias(package_name))
             
-        return success
+            if actual_package:
+                console.print(f"[info]找到别名映射: [bold]{package_name}[/] → [package]{actual_package}[/][/]") 
+                current_package_name = actual_package
+            else:
+                console.print(f"[info]未找到别名，将直接安装: [package]{package_name}[/][/]")
+                current_package_name = package_name
+
+            # 检查SDK版本兼容性
+            package_info = asyncio.run(self._get_package_info(package_name))
+            if package_info and "min_sdk_version" in package_info:
+                is_compatible, message = self._check_sdk_compatibility(package_info["min_sdk_version"])
+                if not is_compatible:
+                    console.print(Panel(
+                        f"[warning]SDK版本兼容性警告[/]\n"
+                        f"包 [package]{current_package_name}[/] 需要最低SDK版本 {package_info['min_sdk_version']}\n"
+                        f"{message}\n\n"
+                        f"继续安装可能会导致问题。",
+                        title="兼容性警告",
+                        border_style="warning"
+                    ))
+                    if not Confirm.ask("是否继续安装？", default=False):
+                        console.print("[info]已取消安装[/]")
+                        all_success = False
+                        continue
+                else:
+                    console.print(f"[success]{message}[/]")
+
+            # 构建pip命令
+            cmd = ["install"]
+            if upgrade:
+                cmd.append("--upgrade")
+            if pre:
+                cmd.append("--pre")
+            cmd.append(current_package_name)
+            
+            # 执行安装命令
+            success, stdout, stderr = self._run_pip_command_with_output(cmd, f"安装 {current_package_name}")
+            
+            if success:
+                console.print(Panel(
+                    f"[success]包 {current_package_name} 安装成功[/]\n\n"
+                    f"[dim]{stdout}[/]",
+                    title="安装完成",
+                    border_style="success"
+                ))
+            else:
+                console.print(Panel(
+                    f"[error]包 {current_package_name} 安装失败[/]\n\n"
+                    f"[dim]{stderr}[/]",
+                    title="安装失败",
+                    border_style="error"
+                ))
+                all_success = False
+        
+        return all_success
     
-    def uninstall_package(self, package_name: str) -> bool:
+    def uninstall_package(self, package_names: List[str]) -> bool:
         """
-        卸载指定包
+        卸载指定包（支持多个包，支持别名）
         
-        :param package_name: 要卸载的包名
+        :param package_names: 要卸载的包名或别名列表
         :return: 卸载是否成功
         """
-        success = self._run_pip_command(
-            ["uninstall", "-y", package_name],
-            f"卸载 {package_name}"
-        )
+        all_success = True
         
-        if success:
-            console.print(f"[success]包 {package_name} 卸载成功[/]")
-        else:
-            console.print(f"[error]包 {package_name} 卸载失败[/]")
+        packages_to_uninstall = []
+        
+        # 首先处理所有包名，查找实际包名
+        for package_name in package_names:
+            # 首先尝试通过别名查找实际包名
+            actual_package = asyncio.run(self._find_package_by_alias(package_name))
             
-        return success
+            if actual_package:
+                console.print(f"[info]找到别名映射: [bold]{package_name}[/] → [package]{actual_package}[/][/]") 
+                packages_to_uninstall.append(actual_package)
+            else:
+                # 如果找不到别名映射，检查是否是已安装的包
+                installed_package = self._find_installed_package_by_name(package_name)
+                if installed_package:
+                    package_name = installed_package
+                    console.print(f"[info]找到已安装包: [bold]{package_name}[/][/]") 
+                    packages_to_uninstall.append(package_name)
+                else:
+                    console.print(f"[warning]未找到别名映射，将尝试直接卸载: [package]{package_name}[/][/]")
+                    packages_to_uninstall.append(package_name)
+
+        # 确认卸载操作
+        package_list = "\n".join([f"  - [package]{pkg}[/]" for pkg in packages_to_uninstall])
+        if not Confirm.ask(f"确认卸载以下包吗？\n{package_list}", default=False):
+            console.print("[info]操作已取消[/]")
+            return False
+
+        # 执行卸载命令
+        for package_name in packages_to_uninstall:
+            success, stdout, stderr = self._run_pip_command_with_output(
+                ["uninstall", "-y", package_name],
+                f"卸载 {package_name}"
+            )
+            
+            if success:
+                console.print(Panel(
+                    f"[success]包 {package_name} 卸载成功[/]\n\n"
+                    f"[dim]{stdout}[/]",
+                    title="卸载完成",
+                    border_style="success"
+                ))
+            else:
+                console.print(Panel(
+                    f"[error]包 {package_name} 卸载失败[/]\n\n"
+                    f"[dim]{stderr}[/]",
+                    title="卸载失败",
+                    border_style="error"
+                ))
+                all_success = False
+        
+        return all_success
     
     def upgrade_all(self) -> bool:
         """
@@ -362,7 +630,7 @@ class PackageManager:
             
         results = {}
         for pkg in sorted(all_packages):
-            results[pkg] = self.install_package(pkg, upgrade=True)
+            results[pkg] = self.install_package([pkg], upgrade=True)
             
         failed = [pkg for pkg, success in results.items() if not success]
         if failed:
@@ -375,6 +643,272 @@ class PackageManager:
             
         return True
 
+    def upgrade_package(self, package_names: List[str], pre: bool = False) -> bool:
+        """
+        升级指定包（支持多个包）
+        
+        :param package_names: 要升级的包名或别名列表
+        :param pre: 是否包含预发布版本
+        :return: 升级是否成功
+        """
+        all_success = True
+        
+        for package_name in package_names:
+            # 首先尝试通过别名查找实际包名
+            actual_package = asyncio.run(self._find_package_by_alias(package_name))
+            
+            if actual_package:
+                console.print(f"[info]找到别名映射: [bold]{package_name}[/] → [package]{actual_package}[/][/]") 
+                current_package_name = actual_package
+            else:
+                current_package_name = package_name
+
+            # 检查SDK版本兼容性
+            package_info = asyncio.run(self._get_package_info(package_name))
+            if package_info and "min_sdk_version" in package_info:
+                is_compatible, message = self._check_sdk_compatibility(package_info["min_sdk_version"])
+                if not is_compatible:
+                    console.print(Panel(
+                        f"[warning]SDK版本兼容性警告[/]\n"
+                        f"包 [package]{current_package_name}[/] 需要最低SDK版本 {package_info['min_sdk_version']}\n"
+                        f"{message}\n\n"
+                        f"继续升级可能会导致问题。",
+                        title="兼容性警告",
+                        border_style="warning"
+                    ))
+                    if not Confirm.ask("是否继续升级？", default=False):
+                        console.print("[info]已取消升级[/]")
+                        all_success = False
+                        continue
+                else:
+                    console.print(f"[success]{message}[/]")
+
+            # 构建pip命令
+            cmd = ["install", "--upgrade"]
+            if pre:
+                cmd.append("--pre")
+            cmd.append(current_package_name)
+            
+            # 执行升级命令
+            success, stdout, stderr = self._run_pip_command_with_output(cmd, f"升级 {current_package_name}")
+            
+            if success:
+                console.print(Panel(
+                    f"[success]包 {current_package_name} 升级成功[/]\n\n"
+                    f"[dim]{stdout}[/]",
+                    title="升级完成",
+                    border_style="success"
+                ))
+            else:
+                console.print(Panel(
+                    f"[error]包 {current_package_name} 升级失败[/]\n\n"
+                    f"[dim]{stderr}[/]",
+                    title="升级失败",
+                    border_style="error"
+                ))
+                all_success = False
+        
+        return all_success
+
+    def search_package(self, query: str) -> Dict[str, List[Dict[str, str]]]:
+        """
+        搜索包（本地和远程）
+        
+        :param query: 搜索关键词
+        :return: 匹配的包信息
+        """
+        normalized_query = self._normalize_name(query)
+        results = {"installed": [], "remote": []}
+        
+        # 搜索已安装的包
+        installed = self.get_installed_packages()
+        for pkg_type in ["modules", "adapters", "cli_extensions"]:
+            for name, info in installed[pkg_type].items():
+                if (normalized_query in self._normalize_name(name) or 
+                    normalized_query in self._normalize_name(info["package"]) or
+                    normalized_query in self._normalize_name(info["summary"])):
+                    results["installed"].append({
+                        "type": pkg_type[:-1] if pkg_type.endswith("s") else pkg_type,  # 移除复数s
+                        "name": name,
+                        "package": info["package"],
+                        "version": info["version"],
+                        "summary": info["summary"]
+                    })
+        
+        # 搜索远程包
+        remote = asyncio.run(self.get_remote_packages())
+        for pkg_type in ["modules", "adapters", "cli_extensions"]:
+            for name, info in remote[pkg_type].items():
+                if (normalized_query in self._normalize_name(name) or 
+                    normalized_query in self._normalize_name(info["package"]) or
+                    normalized_query in self._normalize_name(info.get("description", "")) or
+                    normalized_query in self._normalize_name(info.get("summary", ""))):
+                    results["remote"].append({
+                        "type": pkg_type[:-1] if pkg_type.endswith("s") else pkg_type,  # 移除复数s
+                        "name": name,
+                        "package": info["package"],
+                        "version": info["version"],
+                        "summary": info.get("description", info.get("summary", ""))
+                    })
+        
+        return results
+
+    def get_installed_version(self) -> str:
+        """
+        获取当前安装的ErisPulse版本
+        
+        :return: 当前版本号
+        """
+        try:
+            from ErisPulse import __version__
+            return __version__
+        except ImportError:
+            return "unknown"
+    
+    async def get_pypi_versions(self) -> List[Dict[str, Any]]:
+        """
+        从PyPI获取ErisPulse的所有可用版本
+        
+        :return: 版本信息列表
+        """
+        import aiohttp
+        from aiohttp import ClientError, ClientTimeout
+        from packaging import version as comparison
+        
+        timeout = ClientTimeout(total=10)
+        url = "https://pypi.org/pypi/ErisPulse/json"
+        
+        try:
+            async with aiohttp.ClientSession(timeout=timeout) as session:
+                async with session.get(url) as response:
+                    if response.status == 200:
+                        data = await response.json()
+                        versions = []
+                        for version_str, releases in data["releases"].items():
+                            if releases:  # 只包含有文件的版本
+                                release_info = {
+                                    "version": version_str,
+                                    "uploaded": releases[0].get("upload_time_iso_8601", ""),
+                                    "pre_release": self._is_pre_release(version_str)
+                                }
+                                versions.append(release_info)
+                        
+                        # 使用版本比较函数正确排序版本
+                        versions.sort(key=lambda x: comparison.parse(x["version"]), reverse=True)
+                        return versions
+        except (ClientError, asyncio.TimeoutError, json.JSONDecodeError, KeyError, Exception) as e:
+            console.print(f"[error]获取PyPI版本信息失败: {e}[/]")
+            return []
+    
+    def _is_pre_release(self, version: str) -> bool:
+        """
+        判断版本是否为预发布版本
+        
+        :param version: 版本号
+        :return: 是否为预发布版本
+        """
+        import re
+        # 检查是否包含预发布标识符 (alpha, beta, rc, dev等)
+        pre_release_pattern = re.compile(r'(a|b|rc|dev|alpha|beta)\d*', re.IGNORECASE)
+        return bool(pre_release_pattern.search(version))
+
+    def update_self(self, target_version: str = None, force: bool = False) -> bool:
+        """
+        更新ErisPulse SDK本身
+        
+        :param target_version: 目标版本号，None表示更新到最新版本
+        :param force: 是否强制更新
+        :return: 更新是否成功
+        """
+        current_version = self.get_installed_version()
+        
+        if target_version and target_version == current_version and not force:
+            console.print(f"[info]当前已是目标版本 [bold]{current_version}[/][/]")
+            return True
+        
+        # 确定要安装的版本
+        package_spec = "ErisPulse"
+        if target_version:
+            package_spec += f"=={target_version}"
+        
+        # 检查是否在Windows上且尝试更新自身
+        if sys.platform == "win32":
+            # 构建更新脚本
+            update_script = f"""
+import time
+import subprocess
+import sys
+import os
+
+# 等待原进程结束
+time.sleep(2)
+
+# 执行更新命令
+try:
+    result = subprocess.run([
+        sys.executable, "-m", "pip", "install", "--upgrade", "{package_spec}"
+    ], capture_output=True, text=True, timeout=300)
+    
+    if result.returncode == 0:
+        print("更新成功!")
+        print(result.stdout)
+    else:
+        print("更新失败:")
+        print(result.stderr)
+except Exception as e:
+    print(f"更新过程中出错: {{e}}")
+
+# 清理临时脚本
+try:
+    os.remove(__file__)
+except:
+    pass
+"""
+            # 创建临时更新脚本
+            import tempfile
+            script_path = os.path.join(tempfile.gettempdir(), "epsdk_update.py")
+            with open(script_path, "w", encoding="utf-8") as f:
+                f.write(update_script)
+            
+            # 启动更新进程并退出当前进程
+            console.print("[info]正在启动更新进程...[/]")
+            console.print("[info]请稍后重新运行CLI以使用新版本[/]")
+            
+            subprocess.Popen([
+                sys.executable, script_path
+            ], creationflags=subprocess.CREATE_NEW_CONSOLE)
+            
+            return True
+        else:
+            # 非Windows平台
+            success, stdout, stderr = self._run_pip_command_with_output(
+                ["install", "--upgrade", package_spec],
+                f"更新 ErisPulse SDK {f'到 {target_version}' if target_version else '到最新版本'}"
+            )
+            
+            if success:
+                new_version = target_version or "最新版本"
+                console.print(Panel(
+                    f"[success]ErisPulse SDK 更新成功[/]\n"
+                    f"  当前版本: [bold]{current_version}[/]\n"
+                    f"  更新版本: [bold]{new_version}[/]\n\n"
+                    f"[dim]{stdout}[/]",
+                    title="更新完成",
+                    border_style="success"
+                ))
+                
+                if not target_version:
+                    console.print("[info]请重新启动CLI以使用新版本[/]")
+            else:
+                console.print(Panel(
+                    f"[error]ErisPulse SDK 更新失败[/]\n\n"
+                    f"[dim]{stderr}[/]",
+                    title="更新失败",
+                    border_style="error"
+                ))
+                
+            return success
+
 class ReloadHandler(FileSystemEventHandler):
     """
     文件系统事件处理器
@@ -454,12 +988,44 @@ class ReloadHandler(FileSystemEventHandler):
 
     def _handle_reload(self, event, reason: str):
         """
-        处理重载逻辑
-        
+        处理热重载逻辑
         :param event: 文件系统事件
-        :param reason: 重载原因描述
+        :param reason: 重载原因
         """
-        console.print(f"\n[reload]{reason}: [path]{event.src_path}[/][/]")
+        from ErisPulse.Core import adapter, logger
+        # 在重载前确保所有适配器正确停止
+        try:
+            # 检查适配器是否正在运行
+            if hasattr(adapter, '_started_instances') and adapter._started_instances:
+                logger.info("正在停止适配器...")
+                # 创建新的事件循环来运行异步停止操作
+                import asyncio
+                import threading
+                
+                # 如果在主线程中
+                if threading.current_thread() is threading.main_thread():
+                    try:
+                        # 尝试获取当前事件循环
+                        loop = asyncio.get_running_loop()
+                        # 在新线程中运行适配器停止
+                        stop_thread = threading.Thread(target=lambda: asyncio.run(adapter.shutdown()))
+                        stop_thread.start()
+                        stop_thread.join(timeout=10)  # 最多等待10秒
+                    except RuntimeError:
+                        # 没有运行中的事件循环
+                        asyncio.run(adapter.shutdown())
+                else:
+                    # 在非主线程中，创建新的事件循环
+                    new_loop = asyncio.new_event_loop()
+                    asyncio.set_event_loop(new_loop)
+                    new_loop.run_until_complete(adapter.shutdown())
+                
+                logger.info("适配器已停止")
+        except Exception as e:
+            logger.warning(f"停止适配器时出错: {e}")
+        
+        # 原有的重载逻辑
+        logger.info(f"检测到文件变更 ({reason})，正在重启...")
         self._terminate_process()
         self.start_process()
 
@@ -519,11 +1085,12 @@ class CLI:
         # 安装命令
         install_parser = subparsers.add_parser(
             'install',
-            help='安装模块/适配器包'
+            help='安装模块/适配器包（支持多个，用空格分隔）'
         )
         install_parser.add_argument(
             'package',
-            help='要安装的包名或模块/适配器简称'
+            nargs='+',  # 改为接受多个参数
+            help='要安装的包名或模块/适配器简称（可指定多个）'
         )
         install_parser.add_argument(
             '--upgrade', '-U',
@@ -539,11 +1106,12 @@ class CLI:
         # 卸载命令
         uninstall_parser = subparsers.add_parser(
             'uninstall',
-            help='卸载模块/适配器包'
+            help='卸载模块/适配器包（支持多个，用空格分隔）'
         )
         uninstall_parser.add_argument(
             'package',
-            help='要卸载的包名'
+            nargs='+',  # 改为接受多个参数
+            help='要卸载的包名（可指定多个）'
         )
         
         # 模块管理命令
@@ -613,11 +1181,11 @@ class CLI:
         # 升级命令
         upgrade_parser = subparsers.add_parser(
             'upgrade',
-            help='升级组件'
+            help='升级组件（支持多个，用空格分隔）'
         )
         upgrade_parser.add_argument(
             'package',
-            nargs='?',
+            nargs='*',  # 改为接受可选的多个参数
             help='要升级的包名 (可选，不指定则升级所有)'
         )
         upgrade_parser.add_argument(
@@ -625,6 +1193,52 @@ class CLI:
             action='store_true',
             help='跳过确认直接升级'
         )
+        upgrade_parser.add_argument(
+            '--pre',
+            action='store_true',
+            help='包含预发布版本'
+        )
+        
+        # 搜索命令
+        search_parser = subparsers.add_parser(
+            'search',
+            help='搜索模块/适配器包'
+        )
+        search_parser.add_argument(
+            'query',
+            help='搜索关键词'
+        )
+        search_parser.add_argument(
+            '--installed', '-i',
+            action='store_true',
+            help='仅搜索已安装的包'
+        )
+        search_parser.add_argument(
+            '--remote', '-r',
+            action='store_true',
+            help='仅搜索远程包'
+        )
+        
+        # 自更新命令
+        self_update_parser = subparsers.add_parser(
+            'self-update',
+            help='更新ErisPulse SDK本身'
+        )
+        self_update_parser.add_argument(
+            'version',
+            nargs='?',
+            help='要更新到的版本号 (可选，默认为最新版本)'
+        )
+        self_update_parser.add_argument(
+            '--pre',
+            action='store_true',
+            help='包含预发布版本'
+        )
+        self_update_parser.add_argument(
+            '--force', '-f',
+            action='store_true',
+            help='强制更新，即使版本相同'
+        )
         
         # 运行命令
         run_parser = subparsers.add_parser(
@@ -899,23 +1513,133 @@ class CLI:
     
     def _resolve_package_name(self, short_name: str) -> Optional[str]:
         """
-        解析简称到完整包名
+        解析简称到完整包名（大小写不敏感）
         
         :param short_name: 模块/适配器简称
         :return: 完整包名，未找到返回None
         """
+        normalized_name = self.package_manager._normalize_name(short_name)
         remote_packages = asyncio.run(self.package_manager.get_remote_packages())
         
         # 检查模块
-        if short_name in remote_packages["modules"]:
-            return remote_packages["modules"][short_name]["package"]
-            
+        for name, info in remote_packages["modules"].items():
+            if self.package_manager._normalize_name(name) == normalized_name:
+                return info["package"]
+                
         # 检查适配器
-        if short_name in remote_packages["adapters"]:
-            return remote_packages["adapters"][short_name]["package"]
-            
+        for name, info in remote_packages["adapters"].items():
+            if self.package_manager._normalize_name(name) == normalized_name:
+                return info["package"]
+                
         return None
     
+    def _print_search_results(self, query: str, results: Dict[str, List[Dict[str, str]]]):
+        """
+        打印搜索结果
+        
+        :param query: 搜索关键词
+        :param results: 搜索结果
+        """
+        if not results["installed"] and not results["remote"]:
+            console.print(f"[info]未找到与 '[bold]{query}[/]' 匹配的包[/]")
+            return
+
+        # 打印已安装的包
+        if results["installed"]:
+            table = Table(
+                title="已安装的包",
+                box=SIMPLE,
+                header_style="info"
+            )
+            table.add_column("类型")
+            table.add_column("名称")
+            table.add_column("包名")
+            table.add_column("版本")
+            table.add_column("描述")
+            
+            for item in results["installed"]:
+                table.add_row(
+                    item["type"],
+                    item["name"],
+                    item["package"],
+                    item["version"],
+                    item["summary"]
+                )
+            
+            console.print(table)
+        
+        # 打印远程包
+        if results["remote"]:
+            table = Table(
+                title="远程包",
+                box=SIMPLE,
+                header_style="info"
+            )
+            table.add_column("类型")
+            table.add_column("名称")
+            table.add_column("包名")
+            table.add_column("版本")
+            table.add_column("描述")
+            
+            for item in results["remote"]:
+                table.add_row(
+                    item["type"],
+                    item["name"],
+                    item["package"],
+                    item["version"],
+                    item["summary"]
+                )
+            
+            console.print(table)
+    
+    def _print_version_list(self, versions: List[Dict[str, Any]], include_pre: bool = False):
+        """
+        打印版本列表
+        
+        :param versions: 版本信息列表
+        :param include_pre: 是否包含预发布版本
+        """
+        if not versions:
+            console.print("[info]未找到可用版本[/]")
+            return
+        
+        table = Table(
+            title="可用版本",
+            box=SIMPLE,
+            header_style="info"
+        )
+        table.add_column("序号")
+        table.add_column("版本")
+        table.add_column("类型")
+        table.add_column("上传时间")
+        
+        displayed = 0
+        version_list = []
+        for version_info in versions:
+            # 如果不包含预发布版本，则跳过预发布版本
+            if not include_pre and version_info["pre_release"]:
+                continue
+                
+            version_list.append(version_info)
+            version_type = "[yellow]预发布[/]" if version_info["pre_release"] else "[green]稳定版[/]"
+            table.add_row(
+                str(displayed + 1),
+                version_info["version"],
+                version_type,
+                version_info["uploaded"][:10] if version_info["uploaded"] else "未知"
+            )
+            displayed += 1
+            
+            # 只显示前10个版本
+            if displayed >= 10:
+                break
+        
+        if displayed == 0:
+            console.print("[info]没有找到符合条件的版本[/]")
+        else:
+            console.print(table)
+        return version_list
+    
     def _setup_watchdog(self, script_path: str, reload_mode: bool):
         """
         设置文件监控
@@ -980,16 +1704,19 @@ class CLI:
             
         try:
             if args.command == "install":
-                full_package = self._resolve_package_name(args.package)
-                if full_package:
-                    console.print(f"[info]找到远程包: [bold]{args.package}[/] → [package]{full_package}[/][/]")
-                    self.package_manager.install_package(full_package, args.upgrade)
-                else:
-                    self.package_manager.install_package(args.package, args.upgrade)
+                success = self.package_manager.install_package(
+                    args.package,  # 现在是列表
+                    upgrade=args.upgrade,
+                    pre=args.pre
+                )
+                if not success:
+                    sys.exit(1)
                     
             elif args.command == "uninstall":
-                self.package_manager.uninstall_package(args.package)
-                
+                success = self.package_manager.uninstall_package(args.package)  # 现在是列表
+                if not success:
+                    sys.exit(1)
+                    
             elif args.command == "module":
                 from ErisPulse.Core import mods
                 installed = self.package_manager.get_installed_packages()
@@ -1030,11 +1757,165 @@ class CLI:
                     
             elif args.command == "upgrade":
                 if args.package:
-                    self.package_manager.install_package(args.package, upgrade=True)
+                    success = self.package_manager.upgrade_package(
+                        args.package,  # 现在是列表
+                        pre=args.pre
+                    )
+                    if not success:
+                        sys.exit(1)
                 else:
-                    if args.force or Confirm.ask("确定要升级所有ErisPulse组件吗？"):
-                        self.package_manager.upgrade_all()
+                    if args.force or Confirm.ask("确定要升级所有ErisPulse组件吗？", default=False):
+                        success = self.package_manager.upgrade_all()
+                        if not success:
+                            sys.exit(1)
+                            
+            elif args.command == "search":
+                results = self.package_manager.search_package(args.query)
+                
+                # 根据选项过滤结果
+                if args.installed:
+                    results["remote"] = []
+                elif args.remote:
+                    results["installed"] = []
+                    
+                self._print_search_results(args.query, results)
+                    
+            elif args.command == "self-update":
+                current_version = self.package_manager.get_installed_version()
+                console.print(Panel(
+                    f"[title]ErisPulse SDK 自更新[/]\n"
+                    f"当前版本: [bold]{current_version}[/]",
+                    title_align="left"
+                ))
+                
+                # 获取可用版本
+                with console.status("[bold green]正在获取版本信息...", spinner="dots"):
+                    versions = asyncio.run(self.package_manager.get_pypi_versions())
+                
+                if not versions:
+                    console.print("[error]无法获取版本信息[/]")
+                    sys.exit(1)
+                
+                # 交互式选择更新选项
+                if not args.version:
+                    # 显示最新版本
+                    stable_versions = [v for v in versions if not v["pre_release"]]
+                    pre_versions = [v for v in versions if v["pre_release"]]
+                    
+                    latest_stable = stable_versions[0] if stable_versions else None
+                    latest_pre = pre_versions[0] if pre_versions and args.pre else None
+                    
+                    choices = []
+                    choice_versions = {}
+                    choice_index = {}
+                    
+                    if latest_stable:
+                        choice = f"最新稳定版 ({latest_stable['version']})"
+                        choices.append(choice)
+                        choice_versions[choice] = latest_stable['version']
+                        choice_index[len(choices)] = choice
                         
+                    if args.pre and latest_pre:
+                        choice = f"最新预发布版 ({latest_pre['version']})"
+                        choices.append(choice)
+                        choice_versions[choice] = latest_pre['version']
+                        choice_index[len(choices)] = choice
+                        
+                    # 添加其他选项
+                    choices.append("查看所有版本")
+                    choices.append("手动指定版本")
+                    choices.append("取消")
+                    
+                    # 创建数字索引映射
+                    for i, choice in enumerate(choices, 1):
+                        choice_index[i] = choice
+                    
+                    # 显示选项
+                    console.print("\n[info]请选择更新选项:[/]")
+                    for i, choice in enumerate(choices, 1):
+                        console.print(f"  {i}. {choice}")
+                    
+                    while True:
+                        try:
+                            selected_input = Prompt.ask(
+                                "请输入选项编号",
+                                default="1"
+                            )
+                            
+                            if selected_input.isdigit():
+                                selected_index = int(selected_input)
+                                if selected_index in choice_index:
+                                    selected = choice_index[selected_index]
+                                    break
+                                else:
+                                    console.print("[warning]请输入有效的选项编号[/]")
+                            else:
+                                # 检查是否是选项文本
+                                if selected_input in choices:
+                                    selected = selected_input
+                                    break
+                                else:
+                                    console.print("[warning]请输入有效的选项编号或选项名称[/]")
+                        except KeyboardInterrupt:
+                            console.print("\n[info]操作已取消[/]")
+                            sys.exit(0)
+                    
+                    if selected == "取消":
+                        console.print("[info]操作已取消[/]")
+                        sys.exit(0)
+                    elif selected == "手动指定版本":
+                        target_version = Prompt.ask("请输入要更新到的版本号")
+                        if not any(v['version'] == target_version for v in versions):
+                            console.print(f"[warning]版本 {target_version} 可能不存在[/]")
+                            if not Confirm.ask("是否继续？", default=False):
+                                sys.exit(0)
+                    elif selected == "查看所有版本":
+                        version_list = self._print_version_list(versions, include_pre=args.pre)
+                        if not version_list:
+                            console.print("[info]没有可用版本[/]")
+                            sys.exit(0)
+                            
+                        # 显示版本选择
+                        console.print("\n[info]请选择要更新到的版本:[/]")
+                        while True:
+                            try:
+                                version_input = Prompt.ask("请输入版本序号或版本号")
+                                if version_input.isdigit():
+                                    version_index = int(version_input)
+                                    if 1 <= version_index <= len(version_list):
+                                        target_version = version_list[version_index - 1]['version']
+                                        break
+                                    else:
+                                        console.print("[warning]请输入有效的版本序号[/]")
+                                else:
+                                    # 检查是否是有效的版本号
+                                    if any(v['version'] == version_input for v in version_list):
+                                        target_version = version_input
+                                        break
+                                    else:
+                                        console.print("[warning]请输入有效的版本序号或版本号[/]")
+                            except KeyboardInterrupt:
+                                console.print("\n[info]操作已取消[/]")
+                                sys.exit(0)
+                    else:
+                        target_version = choice_versions[selected]
+                else:
+                    target_version = args.version
+                
+                # 确认更新
+                if target_version == current_version and not args.force:
+                    console.print(f"[info]当前已是目标版本 [bold]{current_version}[/][/]")
+                    sys.exit(0)
+                elif not args.force:
+                    if not Confirm.ask(f"确认将ErisPulse SDK从 [bold]{current_version}[/] 更新到 [bold]{target_version}[/] 吗？", default=False):
+                        console.print("[info]操作已取消[/]")
+                        sys.exit(0)
+                
+                # 执行更新
+                success = self.package_manager.update_self(target_version, args.force)
+                if not success:
+                    sys.exit(1)
+                    
             elif args.command == "run":
                 script = args.script or "main.py"
                 if not os.path.exists(script):
@@ -1046,9 +1927,10 @@ class CLI:
                 
                 try:
                     while True:
-                        time.sleep(1)
+                        time.sleep(0.5)
                 except KeyboardInterrupt:
                     console.print("\n[info]正在安全关闭...[/]")
+                    self._cleanup_adapters()
                     self._cleanup()
                     console.print("[success]已安全退出[/]")
                     
@@ -1087,6 +1969,44 @@ class CLI:
                 console.print(traceback.format_exc())
             self._cleanup()
             sys.exit(1)
+    
+    def _cleanup_adapters(self):
+        """
+        清理适配器资源
+        """
+        from ErisPulse import adapter, logger
+        try:
+            import asyncio
+            import threading
+            
+            # 检查是否有正在运行的适配器
+            if (hasattr(adapter, '_started_instances') and 
+                adapter._started_instances):
+                
+                logger.info("正在停止所有适配器...")
+                
+                if threading.current_thread() is threading.main_thread():
+                    try:
+                        loop = asyncio.get_running_loop()
+                        if loop.is_running():
+                            # 在新线程中运行
+                            stop_thread = threading.Thread(
+                                target=lambda: asyncio.run(adapter.shutdown())
+                            )
+                            stop_thread.start()
+                            stop_thread.join(timeout=5)
+                        else:
+                            asyncio.run(adapter.shutdown())
+                    except RuntimeError:
+                        asyncio.run(adapter.shutdown())
+                else:
+                    new_loop = asyncio.new_event_loop()
+                    asyncio.set_event_loop(new_loop)
+                    new_loop.run_until_complete(adapter.shutdown())
+                    
+                logger.info("适配器已全部停止")
+        except Exception as e:
+            logger.error(f"清理适配器资源时出错: {e}")
 
 def main():
     """