ksaa 2025.11b1__py3-none-any.whl → 2025.11b3__py3-none-any.whl

kaa/main/gr.py

@@ -34,6 +34,11 @@ from kaa.config import (
 from kaa.config.produce import ProduceSolution, ProduceSolutionManager, ProduceData
 from kaa.application.adapter.misc_adapter import create_desktop_shortcut
 from kaa.application.core.idle_mode import IdleModeManager
+from kaa.application.core.update_service import UpdateService
+from kaa.application.core.feedback_service import FeedbackService
+from kaa.errors import (
+    ProduceSolutionNotFoundError, UpdateServiceError, UpdateFetchListError, FeedbackServiceError
+)
 
 logger = logging.getLogger(__name__)
 GradioInput = gr.Textbox | gr.Number | gr.Checkbox | gr.Dropdown | gr.Radio | gr.Slider | gr.Tabs | gr.Tab
@@ -59,7 +64,7 @@ ConfigKey = Literal[
     'select_which_contestant', 'when_no_set',
     
     # produce
-    'produce_enabled', 'selected_solution_id', 'produce_count', 'produce_timeout_cd', 'enable_fever_month',
+    'produce_enabled', 'selected_solution_id', 'produce_count', 'produce_timeout_cd', 'interrupt_timeout', 'enable_fever_month',
     'mission_reward_enabled',
     
     # club reward
@@ -92,7 +97,7 @@ ConfigKey = Literal[
     'trace_recommend_card_detection',
     
     # misc
-    'check_update', 'auto_install_update', 'expose_to_lan', 'update_channel',
+    'check_update', 'auto_install_update', 'expose_to_lan', 'update_channel', 'log_level',
 
     # idle
     'idle_enabled', 'idle_seconds', 'idle_minimize_on_pause',
@@ -104,128 +109,6 @@ CONFIG_KEY_VALUE: tuple[str] = get_args(ConfigKey)
 ConfigSetFunction = Callable[[BaseConfig, Dict[ConfigKey, Any]], None]
 ConfigBuilderReturnValue = Tuple[ConfigSetFunction, Dict[ConfigKey, GradioInput]]
 
-def _save_bug_report(
-    title: str,
-    description: str,
-    version: str,
-    upload: bool,
-    path: str | None = None
-) -> Generator[str, None, str]:
-    """
-    保存报告
-
-    :param title: 标题
-    :param description: 描述
-    :param version: 版本号
-    :param upload: 是否上传
-    :param path: 保存的路径。若为 `None`，则保存到 `./reports/bug-YY-MM-DD HH-MM-SS_标题.zip`。
-    :return: 保存的路径
-    """
-    from kotonebot import device
-    from kotonebot.backend.context import ContextStackVars
-    import re
-
-    # 过滤标题中的非法文件名字符
-    def sanitize_filename(s: str) -> str:
-        # 替换 \/:*?"<>| 为空或下划线
-        return re.sub(r'[\\/:*?"<>|]', '_', s)
-
-    # 确保目录存在
-    os.makedirs('logs', exist_ok=True)
-    os.makedirs('reports', exist_ok=True)
-
-    error = ""
-    if path is None:
-        safe_title = sanitize_filename(title)[:30] or "无标题"
-        timestamp = datetime.now().strftime("%y-%m-%d-%H-%M-%S")
-        path = f'./reports/bug_{timestamp}_{safe_title}.zip'
-    with zipfile.ZipFile(path, 'w', zipfile.ZIP_DEFLATED, compresslevel=9) as zipf:
-        # 打包描述文件
-        yield "### 打包描述文件..."
-        try:
-            description_content = f"标题：{title}\n类型：bug\n内容：\n{description}"
-            zipf.writestr('description.txt', description_content.encode('utf-8'))
-        except Exception as e:
-            error += f"保存描述文件失败：{str(e)}\n"
-
-        # 打包截图
-        yield "### 打包上次截图..."
-        try:
-            stack = ContextStackVars.current()
-            screenshot = None
-            if stack is not None:
-                screenshot = stack._screenshot
-                if screenshot is not None:
-                    img = cv2.imencode('.png', screenshot)[1].tobytes()
-                    zipf.writestr('last_screenshot.png', img)
-            if screenshot is None:
-                error += "无上次截图数据\n"
-        except Exception as e:
-            error += f"保存上次截图失败：{str(e)}\n"
-
-        # 打包当前截图
-        yield "### 打包当前截图..."
-        try:
-            screenshot = device.screenshot()
-            img = cv2.imencode('.png', screenshot)[1].tobytes()
-            zipf.writestr('current_screenshot.png', img)
-        except Exception as e:
-            error += f"保存当前截图失败：{str(e)}\n"
-
-        # 打包配置文件
-        yield "### 打包配置文件..."
-        try:
-            with open('config.json', 'r', encoding='utf-8') as f:
-                zipf.writestr('config.json', f.read())
-        except Exception as e:
-            error += f"保存配置文件失败：{str(e)}\n"
-
-        # 打包 logs 文件夹
-        if os.path.exists('logs'):
-            for root, dirs, files in os.walk('logs'):
-                for file in files:
-                    file_path = os.path.join(root, file)
-                    arcname = os.path.join('logs', os.path.relpath(file_path, 'logs'))
-                    zipf.write(file_path, arcname)
-                    yield f"### 打包 log 文件：{arcname}"
-
-        # 打包 conf 文件夹
-        if os.path.exists('conf'):
-            for root, dirs, files in os.walk('conf'):
-                for file in files:
-                    file_path = os.path.join(root, file)
-                    arcname = os.path.join('conf', os.path.relpath(file_path, 'conf'))
-                    zipf.write(file_path, arcname)
-                    yield f"### 打包配置文件：{arcname}"
-
-        # 写出版本号
-        zipf.writestr('version.txt', version)
-
-    if not upload:
-        yield f"### 报告已保存至 {os.path.abspath(path)}"
-        return path
-
-    # 上传报告
-    from kotonebot.ui.file_host.sensio import upload as upload_file
-    yield "### 上传报告..."
-    url = ''
-    try:
-        url = upload_file(path)
-    except Exception as e:
-        yield f"### 上传报告失败：{str(e)}\n\n"
-        return ''
-
-    final_msg = f"### 报告导出成功：{url}\n\n"
-    expire_time = datetime.now() + timedelta(days=7)
-    if error:
-        final_msg += "### 但发生了以下错误\n\n"
-        final_msg += '\n* '.join(error.strip().split('\n'))
-    final_msg += '\n'
-    final_msg += f"### 此链接将于 {expire_time.strftime('%Y-%m-%d %H:%M:%S')}（7 天后）过期\n\n"
-    final_msg += '### 复制以上文本并反馈给开发者'
-    yield final_msg
-    return path
-
 class KotoneBotUI:
     def __init__(self, kaa: Kaa) -> None:
         self.is_running: bool = False
@@ -234,6 +117,8 @@ class KotoneBotUI:
         self.is_single_task_stopping: bool = False  # 新增：标记单个任务是否正在停止
         self._kaa = kaa
         self._load_config()
+        self.update_service = UpdateService()
+        self.feedback_service = FeedbackService()
         # IdleModeManager 空闲检测
         def safe_get_is_running():
             try:
@@ -1530,6 +1415,14 @@ class KotoneBotUI:
                     info=ProduceConfig.model_fields['produce_timeout_cd'].description
                 )
 
+                interrupt_timeout = gr.Number(
+                    minimum=20,
+                    value=self.current_config.options.produce.interrupt_timeout,
+                    label="检测超时时间",
+                    interactive=True,
+                    info=ProduceConfig.model_fields['interrupt_timeout'].description
+                )
+
                 enable_fever_month = gr.Radio(
                     label="自动启用强化月间",
                     choices=[("不操作", "ignore"), ("自动启用", "on"), ("自动禁用", "off")],
@@ -1556,6 +1449,7 @@ class KotoneBotUI:
             config.produce.selected_solution_id = data.get('selected_solution_id')
             config.produce.produce_count = data.get('produce_count', 1)
             config.produce.produce_timeout_cd = data.get('produce_timeout_cd', 60)
+            config.produce.interrupt_timeout = data.get('interrupt_timeout', 180)
             config.produce.enable_fever_month = data.get('enable_fever_month', 'ignore')
 
         return set_config, {
@@ -1563,6 +1457,7 @@ class KotoneBotUI:
             'selected_solution_id': solution_dropdown,
             'produce_count': produce_count,
             'produce_timeout_cd': produce_timeout_cd,
+            'interrupt_timeout': interrupt_timeout,
             'enable_fever_month': enable_fever_month
         }
 
@@ -2452,6 +2347,16 @@ class KotoneBotUI:
                 info=MiscConfig.model_fields['update_channel'].description,
                 interactive=True
             )
+            log_level = gr.Dropdown(
+                choices=[
+                    ("调试", "debug"),
+                    ("详细", "verbose")
+                ],
+                value=self.current_config.options.misc.log_level,
+                label="日志等级",
+                info=MiscConfig.model_fields['log_level'].description,
+                interactive=True
+            )
             with gr.Row():
                 gr.Button("创建桌面快捷方式").click(
                     fn=self._create_shortcut_button_click(False),
@@ -2467,12 +2372,14 @@ class KotoneBotUI:
             config.misc.auto_install_update = data['auto_install_update']
             config.misc.expose_to_lan = data['expose_to_lan']
             config.misc.update_channel = data['update_channel']
+            config.misc.log_level = data['log_level']
         
         return set_config, {
             'check_update': check_update,
             'auto_install_update': auto_install_update,
             'expose_to_lan': expose_to_lan,
-            'update_channel': update_channel
+            'update_channel': update_channel,
+            'log_level': log_level
         }
 
     def _create_shortcut_button_click(self, start_immediately: bool) -> Callable[[], None]:
@@ -2644,19 +2551,43 @@ class KotoneBotUI:
 
                 result_text = gr.Markdown("等待操作\n\n\n")
 
-            def on_upload_click(title: str, description: str):
-                yield from _save_bug_report(title, description, self._kaa.version, upload=True)
+            def create_report(title: str, description: str, upload: bool, progress=gr.Progress()):
+                
+                def on_progress(data: Dict[str, Any]):
+                    progress_val = data['step'] / data['total_steps']
+                    if data['type'] == 'packing':
+                        desc = f"({data['step']}/{data['total_steps']}) 正在打包 {data['item']}"
+                    elif data['type'] == 'uploading':
+                        desc = f"({data['step']}/{data['total_steps']}) 正在上传 {data['item']}"
+                    elif data['type'] == 'done':
+                        if 'url' in data:
+                            desc = "上传完成"
+                        else:
+                            desc = "已保存至本地"
+                    else:
+                        desc = "正在处理..."
+                    progress(progress_val, desc=desc)
 
-            def on_save_local_click(title: str, description: str):
-                yield from _save_bug_report(title, description, self._kaa.version, upload=False)
+                try:
+                    result = self.feedback_service.report(
+                        title=title,
+                        description=description,
+                        version=self._kaa.version,
+                        upload=upload,
+                        on_progress=on_progress
+                    )
+                    return result.message
+                except FeedbackServiceError as e:
+                    gr.Error(str(e))
+                    return f"### 操作失败\n\n{e}"
 
             upload_report_btn.click(
-                fn=on_upload_click,
+                fn=partial(create_report, upload=True),
                 inputs=[report_title, report_description],
                 outputs=[result_text]
             )
             save_local_report_btn.click(
-                fn=on_save_local_click,
+                fn=partial(create_report, upload=False),
                 inputs=[report_title, report_description],
                 outputs=[result_text]
             )
@@ -2666,18 +2597,12 @@ class KotoneBotUI:
         with gr.Tab("更新"):
             gr.Markdown("## 版本管理")
 
-            # 更新日志
             with gr.Accordion("更新日志", open=False):
                 from kaa.metadata import WHATS_NEW
                 gr.Markdown(WHATS_NEW)
 
-            # 载入信息按钮
             load_info_btn = gr.Button("载入信息", variant="primary")
-
-            # 状态信息
             status_text = gr.Markdown("")
-
-            # 版本选择下拉框（用于安装）
             version_dropdown = gr.Dropdown(
                 label="选择要安装的版本",
                 choices=[],
@@ -2685,405 +2610,71 @@ class KotoneBotUI:
                 visible=False,
                 interactive=True
             )
-
-            # 安装选定版本按钮
             install_selected_btn = gr.Button("安装选定版本", visible=False)
 
-            def list_all_versions():
-                """列出所有可用版本"""
-                import logging
-                import re
-                logger = logging.getLogger(__name__)
-                
-                # 检查启动器版本
-                def check_launcher_version():
-                    """通过读取bootstrap.pyz/meta.py获取启动器版本"""
-                    import zipfile
-                    try:
-                        bootstrap_path = os.path.join(os.getcwd(), "bootstrap.pyz")
-                        if not os.path.exists(bootstrap_path):
-                            logger.warning("启动器文件不存在")
-                            gr.Warning("启动器文件不存在")
-                            return None
-                        
-                        # 尝试从bootstrap.pyz中读取meta.py
-                        try:
-                            with zipfile.ZipFile(bootstrap_path, 'r') as zip_file:
-                                if 'meta.py' in zip_file.namelist():
-                                    # 读取meta.py内容
-                                    meta_content = zip_file.read('meta.py').decode('utf-8')
-                                    
-                                    # 创建一个安全的执行环境
-                                    exec_globals = {}
-                                    exec_locals = {}
-                                    
-                                    # 执行meta.py内容
-                                    exec(meta_content, exec_globals, exec_locals)
-                                    
-                                    # 获取VERSION变量
-                                    if 'VERSION' in exec_locals:
-                                        version = exec_locals['VERSION']
-                                        # 移除v前缀（如果有）
-                                        if isinstance(version, str) and version.startswith('v'):
-                                            version = version[1:]
-                                        logger.info(f"从meta.py读取到启动器版本: {version}")
-                                        return str(version)
-                                    else:
-                                        logger.warning("meta.py中未找到VERSION变量")
-                                        gr.Warning("meta.py中未找到VERSION变量")
-                                        return None
-                                else:
-                                    logger.warning("bootstrap.pyz中未找到meta.py文件")
-                                    gr.Warning("bootstrap.pyz中未找到meta.py文件")
-                                    return None
-                        except zipfile.BadZipFile:
-                            # 不是有效的zip文件，可能是旧版本启动器
-                            logger.info("bootstrap.pyz不是有效的zip文件，判断为旧版本启动器")
-                            return "0.4.x"
-                        except Exception as e:
-                            logger.warning(f"读取bootstrap.pyz失败: {str(e)}")
-                            gr.Warning(f"读取bootstrap.pyz失败: {str(e)}")
-                            return None
-                            
-                    except Exception as e:
-                        logger.warning(f"检查启动器版本失败: {str(e)}")
-                        gr.Warning(f"检查启动器版本失败: {str(e)}")
-                        return None
-
+            def on_load_info():
+                """使用 UpdateService 加载版本信息。"""
+                yield (
+                    "正在载入版本信息...",
+                    gr.Button(value="载入中...", interactive=False),
+                    gr.Dropdown(visible=False),
+                    gr.Button(visible=False)
+                )
                 try:
-                    # 构建命令，使用清华镜像源
-                    cmd = [
-                        sys.executable, "-m", "pip", "index", "versions", "ksaa", "--json", "--pre",
-                        "--index-url", "https://mirrors.tuna.tsinghua.edu.cn/pypi/web/simple",
-                        "--trusted-host", "mirrors.tuna.tsinghua.edu.cn"
-                    ]
-                    logger.info(f"执行命令: {' '.join(cmd)}")
-
-                    # 使用 pip index versions --json 来获取版本信息
-                    result = subprocess.run(
-                        cmd,
-                        capture_output=True,
-                        text=True,
-                        timeout=30
-                    )
-
-                    logger.info(f"命令返回码: {result.returncode}")
-                    if result.stdout:
-                        logger.info(f"命令输出: {result.stdout[:500]}...")  # 只记录前500字符
-                    if result.stderr:
-                        logger.warning(f"命令错误输出: {result.stderr}")
-
-                    if result.returncode != 0:
-                        error_msg = f"获取版本列表失败: {result.stderr}"
-                        logger.error(error_msg)
-                        return (
-                            error_msg,
-                            gr.Button(value="载入信息", interactive=True),
-                            gr.Dropdown(visible=False),
-                            gr.Button(visible=False)
-                        )
-
-                    # 解析 JSON 输出
-                    try:
-                        data = json.loads(result.stdout)
-                        versions = data.get("versions", [])
-                        latest_version = data.get("latest", "")
-                        installed_version = data.get("installed_version", "")
-
-                        logger.info(f"解析到 {len(versions)} 个版本")
-                        logger.info(f"最新版本: {latest_version}")
-                        logger.info(f"已安装版本: {installed_version}")
-
-                    except json.JSONDecodeError as e:
-                        error_msg = f"解析版本信息失败: {str(e)}"
-                        logger.error(error_msg)
-                        return (
-                            error_msg,
-                            gr.Button(value="载入信息", interactive=True),
-                            gr.Dropdown(visible=False),
-                            gr.Button(visible=False)
-                        )
-
-                    if not versions:
-                        error_msg = "未找到可用版本"
-                        logger.warning(error_msg)
-                        return (
-                            error_msg,
-                            gr.Button(value="载入信息", interactive=True),
-                            gr.Dropdown(visible=False),
-                            gr.Button(visible=False)
-                        )
-
-                    # 检查启动器版本
-                    launcher_version = check_launcher_version()
-                    
-                    # 构建状态信息
-                    status_info = []
-                    if installed_version:
-                        status_info.append(f"**当前安装版本:** {installed_version}")
-                    if latest_version:
-                        status_info.append(f"**最新版本:** {latest_version}")
-                    if launcher_version:
-                        if launcher_version == "0.4.x":
-                            status_info.append(f"**启动器版本:** < v0.5.0 (旧版本)")
-                        else:
-                            status_info.append(f"**启动器版本:** v{launcher_version}")
-                    else:
-                        status_info.append(f"**启动器版本:** 未知")
-                    status_info.append(f"**找到 {len(versions)} 个可用版本**")
-
-                    status_message = "\n\n".join(status_info)
-                    logger.info(f"版本信息载入完成: {status_message}")
-
-                    # 返回更新后的组件
-                    return (
-                        status_message,
-                        gr.Button(value="载入信息", interactive=True),
-                        gr.Dropdown(choices=versions, value=versions[0] if versions else None, visible=True, label="选择要安装的版本"),
-                        gr.Button(visible=True, value="安装选定版本")
-                    )
-
-                except subprocess.TimeoutExpired:
-                    error_msg = "获取版本列表超时"
-                    logger.error(error_msg)
-                    return (
-                        error_msg,
-                        gr.Button(value="载入信息", interactive=True),
-                        gr.Dropdown(visible=False),
-                        gr.Button(visible=False)
-                    )
-                except Exception as e:
-                    error_msg = f"获取版本列表失败: {str(e)}"
-                    logger.error(error_msg)
-                    return (
-                        error_msg,
+                    versions_data = self.update_service.list_remote_versions()
+                except UpdateFetchListError as e:
+                    gr.Error(str(e))
+                    yield (
+                        str(e),
                         gr.Button(value="载入信息", interactive=True),
                         gr.Dropdown(visible=False),
                         gr.Button(visible=False)
                     )
+                    return
 
-            def install_selected_version(selected_version: str):
-                """安装选定的版本"""
-                import logging
-                import threading
-                import time
-                import re
-                logger = logging.getLogger(__name__)
-
-                if not selected_version:
-                    error_msg = "请先选择一个版本"
-                    logger.warning(error_msg)
-                    return error_msg
-                
-
-                def compare_version(version1: str, version2: str) -> int:
-                    """比较版本号，返回-1(v1<v2), 0(v1==v2), 1(v1>v2)"""
-                    # 处理特殊标记
-                    if version1 == "0.4.x":
-                        version1 = "0.4.0"
-                    
-                    def parse_version(v):
-                        # 移除v前缀并解析版本号和预发布标识
-                        v = v.lstrip('v')
-                        if 'b' in v:
-                            base, beta = v.split('b', 1)
-                            return tuple(map(int, base.split('.'))) + (-1, int(beta))
-                        elif 'a' in v:
-                            base, alpha = v.split('a', 1)
-                            return tuple(map(int, base.split('.'))) + (-2, int(alpha))
-                        elif 'rc' in v:
-                            base, rc = v.split('rc', 1)
-                            return tuple(map(int, base.split('.'))) + (-0.5, int(rc))
-                        else:
-                            return tuple(map(int, v.split('.'))) + (0, 0)
-                    
-                    v1_parsed = parse_version(version1)
-                    v2_parsed = parse_version(version2)
-                    
-                    if v1_parsed < v2_parsed:
-                        return -1
-                    elif v1_parsed > v2_parsed:
-                        return 1
+                status_info = [
+                    f"**当前安装版本:** {versions_data.installed_version or '未知'}",
+                    f"**最新版本:** {versions_data.latest or '未知'}",
+                ]
+                if versions_data.launcher_version:
+                    if versions_data.launcher_version == "0.4.x":
+                        status_info.append("**启动器版本:** < v0.5.0 (旧版本)")
                     else:
-                        return 0
-                
-                # 检查启动器版本进行兼容性验证
-                def check_launcher_version_simple():
-                    """通过读取bootstrap.pyz/meta.py获取启动器版本"""
-                    import zipfile
-                    try:
-                        bootstrap_path = os.path.join(os.getcwd(), "bootstrap.pyz")
-                        if not os.path.exists(bootstrap_path):
-                            logger.warning("启动器文件不存在")
-                            gr.Warning("启动器文件不存在")
-                            return None
-                        
-                        # 尝试从bootstrap.pyz中读取meta.py
-                        try:
-                            with zipfile.ZipFile(bootstrap_path, 'r') as zip_file:
-                                if 'meta.py' in zip_file.namelist():
-                                    # 读取meta.py内容
-                                    meta_content = zip_file.read('meta.py').decode('utf-8')
-                                    
-                                    # 创建一个安全的执行环境
-                                    exec_globals = {}
-                                    exec_locals = {}
-                                    
-                                    # 执行meta.py内容
-                                    exec(meta_content, exec_globals, exec_locals)
-                                    
-                                    # 获取VERSION变量
-                                    if 'VERSION' in exec_locals:
-                                        version = exec_locals['VERSION']
-                                        # 移除v前缀（如果有）
-                                        if isinstance(version, str) and version.startswith('v'):
-                                            version = version[1:]
-                                        logger.info(f"从meta.py读取到启动器版本: {version}")
-                                        return str(version)
-                                    else:
-                                        logger.warning("meta.py中未找到VERSION变量")
-                                        gr.Warning("meta.py中未找到VERSION变量")
-                                        return None
-                                else:
-                                    logger.warning("bootstrap.pyz中未找到meta.py文件")
-                                    gr.Warning("bootstrap.pyz中未找到meta.py文件")
-                                    return None
-                        except zipfile.BadZipFile:
-                            # 不是有效的zip文件，可能是旧版本启动器
-                            logger.info("bootstrap.pyz不是有效的zip文件，判断为旧版本启动器")
-                            return "0.4.x"
-                        except Exception as e:
-                            logger.warning(f"读取bootstrap.pyz失败: {str(e)}")
-                            gr.Warning(f"读取bootstrap.pyz失败: {str(e)}")
-                            return None
-                            
-                    except Exception as e:
-                        logger.warning(f"检查启动器版本失败: {str(e)}")
-                        gr.Warning(f"检查启动器版本失败: {str(e)}")
-                        return None
-                
-                # 执行启动器版本检查
-                launcher_version = check_launcher_version_simple()
-                logger.info(f"检测到启动器版本: {launcher_version}")
-                
-                # 版本兼容性检查
-                if launcher_version:
-                    if compare_version(launcher_version, "0.5.0") < 0:
-                        # 启动器版本低于0.5.0
-                        logger.warning(f"启动器版本 {launcher_version} 低于 v0.5.0")
-                        
-                        # 检查要安装的版本是否 >= v2025.9b1
-                        if compare_version(selected_version, "2025.9b1") >= 0:
-                            error_msg = (
-                                f"❌ 版本兼容性错误\n\n"
-                                f"启动器版本: {launcher_version}\n"
-                                f"要安装的版本: {selected_version}\n\n"
-                                f"v2025.9b1 及以上版本需要**启动器 v0.5.0*** 或更高版本支持。\n"
-                                f"请先升级启动器到 v0.5.0 以上版本。[查看帮助](https://www.kdocs.cn/l/cetCY8mGKHLj?linkname=UhPH1itaSv)"
-                            )
-                            logger.error(error_msg)
-                            return error_msg
-                        else:
-                            # 版本兼容，但给出警告
-                            logger.warning(f"启动器版本较低，建议升级到 v0.5.0 以上")
-                            gr.Warning("启动器版本较低，建议升级到 v0.5.0 以上")
+                        status_info.append(f"**启动器版本:** v{versions_data.launcher_version}")
                 else:
-                    # 无法获取启动器版本，给出警告但继续
-                    logger.warning("无法获取启动器版本，可以继续安装但可能存在兼容性问题")
-                    gr.Warning("无法获取启动器版本，可以继续安装但可能存在兼容性问题")
-
-                def install_and_exit():
-                    """在后台线程中执行安装并退出程序"""
-                    try:
-                        # 等待一小段时间确保UI响应已返回
-                        time.sleep(1)
-
-                        # 构建启动器命令
-                        bootstrap_path = os.path.join(os.getcwd(), "bootstrap.pyz")
-                        cmd = [sys.executable, bootstrap_path, f"--install-version={selected_version}"]
-                        logger.info(f"开始通过启动器安装版本 {selected_version}")
-                        logger.info(f"执行命令: {' '.join(cmd)}")
-
-                        # 启动启动器进程（不等待完成）
-                        subprocess.Popen(
-                            cmd,
-                            cwd=os.getcwd(),
-                            creationflags=subprocess.CREATE_NEW_CONSOLE if os.name == 'nt' else 0
-                        )
-
-                        # 退出当前程序
-                        logger.info("安装即将开始，正在退出当前程序...")
-                        os._exit(0)
-
-                    except Exception as e:
-                        raise
-
-                try:
-                    # 在后台线程中执行安装和退出
-                    install_thread = threading.Thread(target=install_and_exit, daemon=True)
-                    install_thread.start()
-
-                    return f"正在启动器中安装版本 {selected_version}，程序将自动重启..."
-
-                except Exception as e:
-                    error_msg = f"启动安装进程失败: {str(e)}"
-                    logger.error(error_msg)
-                    return error_msg
-
-            def load_info_with_button_state():
-                """载入信息并管理按钮状态"""
-                import logging
-                logger = logging.getLogger(__name__)
-
-                logger.info("开始载入版本信息")
+                    status_info.append("**启动器版本:** 未知")
+                
+                status_info.append(f"**找到 {len(versions_data.versions)} 个可用版本**")
+                status_message = "\n\n".join(status_info)
 
-                # 先禁用按钮
                 yield (
-                    "正在载入版本信息...",
-                    gr.Button(value="载入中...", interactive=False),
-                    gr.Dropdown(visible=False),
-                    gr.Button(visible=False)
+                    status_message,
+                    gr.Button(value="载入信息", interactive=True),
+                    gr.Dropdown(choices=versions_data.versions, value=versions_data.versions[0] if versions_data.versions else None, visible=True),
+                    gr.Button(visible=True)
                 )
 
-                # 执行载入操作
-                result = list_all_versions()
-                logger.info("版本信息载入操作完成")
-                yield result
+            def on_install_selected(selected_version: str):
+                """使用 UpdateService 安装所选版本。"""
+                if not selected_version:
+                    gr.Warning("请先选择一个版本。")
+                    return
+
+                try:
+                    self.update_service.install_version(selected_version)
+                    gr.Info(f"正在启动器中安装版本 {selected_version}，程序将自动重启...")
+                except UpdateServiceError as e:
+                    gr.Error(str(e))
 
-            # 绑定事件
             load_info_btn.click(
-                fn=load_info_with_button_state,
+                fn=on_load_info,
                 outputs=[status_text, load_info_btn, version_dropdown, install_selected_btn]
             )
 
             install_selected_btn.click(
-                fn=install_selected_version,
+                fn=on_install_selected,
                 inputs=[version_dropdown],
-                outputs=[status_text]
-            )
-
-    def _create_screen_tab(self) -> None:
-        with gr.Tab("画面"):
-            gr.Markdown("## 当前设备画面")
-            refresh_btn = gr.Button("刷新画面", variant="primary")
-            WIDTH = 720 // 3
-            HEIGHT = 1280 // 3
-            last_update_text = gr.Markdown("上次更新时间：无数据")
-            screenshot_display = gr.Image(type="numpy", width=WIDTH, height=HEIGHT)
-
-            def update_screenshot():
-                ctx = ContextStackVars.current()
-                if ctx is None:
-                    return [None, "上次更新时间：无上下文数据"]
-                screenshot = ctx._screenshot
-                if screenshot is None:
-                    return [None, "上次更新时间：无截图数据"]
-                screenshot = cv2.cvtColor(screenshot, cv2.COLOR_BGR2RGB)
-                return screenshot, f"上次更新时间：{datetime.now().strftime('%Y-%m-%d %H:%M:%S')}"
-
-            refresh_btn.click(
-                fn=update_screenshot,
-                outputs=[screenshot_display, last_update_text]
+                outputs=[] 
             )
 
     def _load_config(self) -> None:
@@ -3128,7 +2719,6 @@ class KotoneBotUI:
                     self._create_produce_tab()
                     self._create_log_tab()
                     self._create_whats_new_tab()
-                    self._create_screen_tab()
 
         # 启动 IdleModeManager 后台线程
         self.idle_mgr.start()