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

kaa/main/gr.py

@@ -1,78 +1,2740 @@
-import logging
+import os
 import traceback
+import zipfile
+import logging
+import copy
+import sys
+import subprocess
+import json
+from functools import partial
+from itertools import chain
+from datetime import datetime, timedelta
+from typing import List, Dict, Tuple, Literal, Generator, Callable, Any, get_args, cast
+
+import cv2
 import gradio as gr
 
-from kaa.main.kaa import Kaa
-from kaa.application.ui.facade import KaaFacade
-from kaa.application.ui.gradio_view import KaaGradioView
-
-custom_css = """
-.no-padding-dropdown {
-    padding: 0 !important;
-}
-.no-padding-dropdown > label {
-    padding: 0 !important;
-}
-.no-padding-dropdown > div {
-    padding: 0 !important;
-}
-"""
-
-def main(kaa_ins: Kaa, start_immediately: bool = False):
-    """
-    Main entry point for the KAA Gradio application.
-    Initializes the core application, facade, and UI view, then launches the UI.
-    """
-    # Configure basic logging
-    logging.basicConfig(level=logging.INFO, format='[%(asctime)s][%(levelname)s][%(name)s] %(message)s')
-    logger = logging.getLogger(__name__)
-
-    try:
-        # 1. Initialize Model/Core Application
-        # The Kaa instance holds the core application logic and state.
-        kaa_instance = kaa_ins
-        
-        # 2. Initialize Facade
-        # The Facade is the single point of entry for the UI to interact with the backend.
-        # It orchestrates the various services.
-        facade = KaaFacade(kaa_instance)
-
-        # Set log level from config
-        log_level_str = facade.config_service.get_options().misc.log_level
-        log_level = logging.DEBUG if log_level_str == 'verbose' else logging.INFO
-        logging.getLogger().setLevel(log_level)
-        logger.info(f"Log level set to {log_level_str.upper()}")
-
-
-        # 3. Initialize View
-        # The View is responsible for building and rendering the UI.
-        # It only interacts with the Facade.
-        view = KaaGradioView(facade)
-
-        # 4. Create and launch the Gradio UI
-        blocks = view.create_ui()
-        
-        if start_immediately:
-            facade.start_all_tasks()
-
-        misc_opts = facade.config_service.get_options().misc
-        logger.info(f"Launching Gradio UI... LAN exposure: {misc_opts.expose_to_lan}")
-        
-        blocks.launch(
-            share=misc_opts.expose_to_lan,
-            inbrowser=True,
-            css=custom_css
+from kaa.errors import ProduceSolutionNotFoundError
+from kaa.main import Kaa
+from kaa.db import IdolCard
+from kotonebot.backend.context.context import vars
+from kotonebot.errors import ContextNotInitializedError
+from kotonebot.client.host import Mumu12Host, LeidianHost
+from kotonebot.client.host.mumu12_host import Mumu12V5Host
+from kotonebot.config.manager import load_config, save_config
+from kotonebot.config.base_config import UserConfig, BackendConfig
+from kotonebot.backend.context import task_registry, ContextStackVars
+from kaa.config import (
+    BaseConfig, APShopItems, CapsuleToysConfig, ClubRewardConfig, PurchaseConfig, ActivityFundsConfig,
+    PresentsConfig, AssignmentConfig, ContestConfig, ProduceConfig,
+    MissionRewardConfig, DailyMoneyShopItems, ProduceAction,
+    RecommendCardDetectionMode, TraceConfig, StartGameConfig, EndGameConfig, UpgradeSupportCardConfig, MiscConfig,
+    IdleModeConfig,
+)
+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
+ConfigKey = Literal[
+    # backend
+    'adb_ip', 'adb_port',
+    'screenshot_method', 'keep_screenshots',
+    'check_emulator', 'emulator_path',
+    'adb_emulator_name', 'emulator_args',
+    '_mumu_index', '_mumu12v5_index', '_leidian_index',
+    'mumu_background_mode', 'target_screenshot_interval',
+
+    # purchase
+    'purchase_enabled',
+    'money_enabled', 'ap_enabled',
+    'ap_items', 'money_items', 'money_refresh',
+    
+    # assignment
+    'assignment_enabled',
+    'mini_live_reassign', 'mini_live_duration',
+    'online_live_reassign', 'online_live_duration',
+    'contest_enabled',
+    'select_which_contestant', 'when_no_set',
+    
+    # produce
+    'produce_enabled', 'selected_solution_id', 'produce_count', 'produce_timeout_cd', 'interrupt_timeout', 'enable_fever_month',
+    'mission_reward_enabled',
+    
+    # club reward
+    'club_reward_enabled',
+    'selected_note',
+    
+    # upgrade support card
+    'upgrade_support_card_enabled',
+    
+    # capsule toys
+    'capsule_toys_enabled', 'friend_capsule_toys_count',
+    'sense_capsule_toys_count', 'logic_capsule_toys_count',
+    'anomaly_capsule_toys_count',
+    
+    # start game
+    'start_game_enabled', 'start_through_kuyo',
+    'game_package_name', 'kuyo_package_name',
+    'disable_gakumas_localify', 'dmm_game_path', 'dmm_bypass',
+
+    # end game
+    'exit_kaa', 'kill_game', 'kill_dmm',
+    'kill_emulator', 'shutdown', 'hibernate',
+    'restore_gakumas_localify',
+    
+    'activity_funds',
+    'presents',
+    'mission_reward',
+    'activity_funds_enabled',
+    'presents_enabled',
+    'trace_recommend_card_detection',
+    
+    # misc
+    'check_update', 'auto_install_update', 'expose_to_lan', 'update_channel', 'log_level',
+
+    # idle
+    'idle_enabled', 'idle_seconds', 'idle_minimize_on_pause',
+
+    '_selected_backend_index'
+    
+]
+CONFIG_KEY_VALUE: tuple[str] = get_args(ConfigKey)
+ConfigSetFunction = Callable[[BaseConfig, Dict[ConfigKey, Any]], None]
+ConfigBuilderReturnValue = Tuple[ConfigSetFunction, Dict[ConfigKey, GradioInput]]
+
+class KotoneBotUI:
+    def __init__(self, kaa: Kaa) -> None:
+        self.is_running: bool = False
+        self.single_task_running: bool = False
+        self.is_stopping: bool = False  # 新增：标记是否正在停止过程中
+        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:
+                return (self.is_running or self.single_task_running) and not self.is_stopping and not self.is_single_task_stopping and not vars.flow.is_paused
+            except ContextNotInitializedError:
+                return False
+
+        def safe_get_is_paused():
+            try:
+                return vars.flow.is_paused
+            except ContextNotInitializedError:
+                return False
+
+        self.idle_mgr = IdleModeManager(
+            get_is_running=safe_get_is_running,
+            get_is_paused=safe_get_is_paused,
+            get_config=lambda: self.current_config.options.idle,
+        )
+        self._setup_kaa()
+
+    def _setup_kaa(self) -> None:
+        from kotonebot.backend.debug.vars import debug, clear_saved
+
+        self._kaa.initialize()
+        if self.current_config.keep_screenshots:
+            debug.auto_save_to_folder = 'dumps'
+            debug.enabled = True
+            clear_saved()
+        else:
+            debug.auto_save_to_folder = None
+            debug.enabled = False
+
+    def export_dumps(self) -> str:
+        """导出 dumps 文件夹为 zip 文件"""
+        if not os.path.exists('dumps'):
+            return "dumps 文件夹不存在"
+
+        timestamp = datetime.now().strftime('%y-%m-%d-%H-%M-%S')
+        zip_filename = f'dumps-{timestamp}.zip'
+
+        with zipfile.ZipFile(zip_filename, 'w', zipfile.ZIP_DEFLATED, compresslevel=9) as zipf:
+            for root, dirs, files in os.walk('dumps'):
+                for file in files:
+                    file_path = os.path.join(root, file)
+                    arcname = os.path.relpath(file_path, 'dumps')
+                    zipf.write(file_path, arcname)
+
+        return f"已导出到 {zip_filename}"
+
+    def export_logs(self) -> str:
+        """导出 logs 文件夹为 zip 文件"""
+        if not os.path.exists('logs'):
+            return "logs 文件夹不存在"
+
+        timestamp = datetime.now().strftime('%y-%m-%d-%H-%M-%S')
+        zip_filename = f'logs-{timestamp}.zip'
+
+        with zipfile.ZipFile(zip_filename, 'w', zipfile.ZIP_DEFLATED, compresslevel=9) as zipf:
+            for root, dirs, files in os.walk('logs'):
+                for file in files:
+                    file_path = os.path.join(root, file)
+                    arcname = os.path.relpath(file_path, 'logs')
+                    zipf.write(file_path, arcname)
+
+        return f"已导出到 {zip_filename}"
+
+    def get_button_status(self) -> Tuple[str, bool]:
+        """获取按钮状态和交互性"""
+        if not hasattr(self, 'run_status'):
+            return "启动", True
+
+        if not self.run_status.running:
+            self.is_running = False
+            self.is_stopping = False  # 重置停止状态
+            return "启动", True
+
+        if self.is_stopping:
+            return "停止中...", False  # 停止中时禁用按钮
+
+        return "停止", True
+
+    def update_task_status(self) -> List[List[str]]:
+        status_list: List[List[str]] = []
+        if not hasattr(self, 'run_status'):
+            for task_name, task in task_registry.items():
+                status_list.append([task.name, "等待中"])
+            return status_list
+
+        for task_status in self.run_status.tasks:
+            status_text = {
+                'pending': '等待中',
+                'running': '运行中',
+                'finished': '已完成',
+                'error': '出错',
+                'cancelled': '已取消'
+            }.get(task_status.status, '未知')
+            status_list.append([task_status.task.name, status_text])
+        return status_list
+
+    def toggle_run(self) -> Tuple[str, List[List[str]]]:
+        if not self.is_running:
+            return self.start_run()
+
+        # 如果正在停止过程中，忽略重复点击
+        if self.is_stopping:
+            return "停止中...", self.update_task_status()
+
+        return self.stop_run()
+
+    def start_run(self) -> Tuple[str, List[List[str]]]:
+        self.is_running = True
+        self.run_status = self._kaa.start_all()
+        # 通知 Idle 管理器进入运行态
+        self.idle_mgr.notify_on_start()
+        return "停止", self.update_task_status()
+
+    def stop_run(self) -> Tuple[str, List[List[str]]]:
+        self.is_stopping = True  # 设置停止状态
+
+        # 如果当前处于暂停状态，先恢复再停止
+        if vars.flow.is_paused:
+            gr.Info("检测到任务暂停，正在恢复后停止...")
+            vars.flow.request_resume()
+
+        self.is_running = False
+        if self._kaa:
+            self.run_status.interrupt()
+            gr.Info("正在停止任务...")
+        # 通知 Idle 管理器停止态
+        self.idle_mgr.notify_on_stop()
+
+        return "停止中...", self.update_task_status()
+
+    def start_single_task(self, task_name: str) -> Tuple[str, str]:
+        if not task_name:
+            gr.Warning("请先选择一个任务")
+            return "执行任务", ""
+        task = None
+        for name, t in task_registry.items():
+            if name == task_name:
+                task = t
+                break
+        if task is None:
+            gr.Warning(f"任务 {task_name} 未找到")
+            return "执行任务", ""
+
+        gr.Info(f"任务 {task_name} 开始执行")
+        self.single_task_running = True
+        self.run_status = self._kaa.start([task])
+        return "停止任务", f"正在执行任务: {task_name}"
+
+    def stop_single_task(self) -> Tuple[str, str]:
+        self.is_single_task_stopping = True  # 设置单个任务停止状态
+
+        # 如果当前处于暂停状态，先恢复再停止
+        if vars.flow.is_paused:
+            gr.Info("检测到任务暂停，正在恢复后停止...")
+            vars.flow.request_resume()
+
+        self.single_task_running = False
+        if hasattr(self, 'run_status') and self._kaa:
+            self.run_status.interrupt()
+            gr.Info("正在停止任务...")
+        # 通知 Idle 管理器停止态
+        self.idle_mgr.notify_on_stop()
+        return "停止中...", "正在停止任务..."
+
+    def toggle_pause(self) -> str:
+        """切换暂停/恢复状态"""
+        if vars.flow.is_paused:
+            vars.flow.request_resume()
+            gr.Info("任务已恢复")
+            return "暂停"
+        else:
+            vars.flow.request_pause()
+            gr.Info("任务已暂停")
+            return "恢复"
+
+    def get_pause_button_status(self) -> str:
+        """获取暂停按钮的状态"""
+        if vars.flow.is_paused:
+            return "恢复"
+        else:
+            return "暂停"
+
+    def get_pause_button_with_interactive(self) -> gr.Button:
+        """获取暂停按钮的状态和交互性"""
+        try:
+            text = "恢复" if vars.flow.is_paused else "暂停"
+        except ContextNotInitializedError:
+            # ContextNotInitializedError: Forwarded object vars called before initialization.
+            # TODO: vars.flow.is_paused 应该要可以在脚本正式启动前就能访问
+            text = '未启动'
+        # 如果正在停止过程中，禁用暂停按钮
+        interactive = not (self.is_stopping or self.is_single_task_stopping)
+        return gr.Button(value=text, interactive=interactive)
+        
+    def reload_config(self) -> bool:
+        """
+        重新加载配置并重新初始化相关组件
+
+        :return: 是否成功重新加载
+        """
+        try:
+            # 重新加载配置文件
+            self._load_config()
+
+            # 重新设置 kaa 的配置
+            self._kaa.config_path = "config.json"
+            self._kaa.config_type = BaseConfig
+
+            # 重新初始化 kaa（这会重新创建设备和 Context）
+            self._setup_kaa()
+
+            # 重新加载 Context 中的配置数据
+            from kotonebot.backend.context.context import config
+            try:
+                config.load()
+            except ContextNotInitializedError:
+                pass
+
+            logger.info("配置已成功重新加载")
+            return True
+        except Exception as e:
+            logger.error(f"重新加载配置失败：{str(e)}")
+            return False
+
+    def save_settings2(self, return_values: list[ConfigBuilderReturnValue], *args) -> str:
+        options = BaseConfig()
+        # return_values: (set_func, { 'key': component })
+        keys = list(chain.from_iterable([list(data.keys()) for _, data in return_values]))
+        # 根据 keys 与 *args 构建 data 字典
+        data = dict[ConfigKey, Any]()
+        assert len(keys) == len(args), "keys 与 args 长度不一致"
+        for key, value in zip(keys, args):
+            assert key in CONFIG_KEY_VALUE, f"未知的配置项：{key}"
+            key = cast(ConfigKey, key)
+            data[key] = value
+
+        # 先设置options
+        for (set_func, _) in return_values:
+            set_func(options, data)
+
+        # 验证规则1：截图方法验证
+        screenshot_method = self.current_config.backend.screenshot_impl
+        backend_type = self.current_config.backend.type
+
+        valid_screenshot_methods = {
+            'mumu12': ['adb', 'adb_raw', 'uiautomator2', 'nemu_ipc'],
+            'mumu12v5': ['adb', 'adb_raw', 'uiautomator2', 'nemu_ipc'],
+            'leidian': ['adb', 'adb_raw', 'uiautomator2'],
+            'custom': ['adb', 'adb_raw', 'uiautomator2'],
+            'dmm': ['remote_windows', 'windows']
+        }
+
+        if screenshot_method not in valid_screenshot_methods.get(backend_type, []):
+            gr.Warning(f"截图方法 '{screenshot_method}' 不适用于当前选择的模拟器类型，配置未保存。")
+            return ""
+
+        # 验证规则2：若启用培育，那么必须选择培育方案
+        if options.produce.enabled and not options.produce.selected_solution_id:
+            gr.Warning("启用培育时，必须选择培育方案，配置未保存。")
+            return ""
+
+        # 验证规则3：若启用AP/金币购买，对应的商品不能为空
+        if options.purchase.ap_enabled and not options.purchase.ap_items:
+            gr.Warning("启用AP购买时，AP商店购买物品不能为空，配置未保存。")
+            return ""
+
+        if options.purchase.money_enabled and not options.purchase.money_items:
+            gr.Warning("启用金币购买时，金币商店购买物品不能为空，配置未保存。")
+            return ""
+
+        # 验证通过，保存配置
+        self.current_config.options = options
+        try:
+            save_config(self.config, "config.json")
+
+            # 尝试热重载配置
+            if self.reload_config():
+                gr.Success("设置已保存并应用！")
+            else:
+                gr.Warning("设置已保存，但重新加载失败，请重启程序。")
+            return ""
+        except Exception as e:
+            gr.Warning(f"保存设置失败：{str(e)}")
+            return ""
+
+    def _create_status_tab(self) -> None:
+        with gr.Tab("状态"):
+            gr.Markdown("## 状态")
+
+            with gr.Row():
+                run_btn = gr.Button("启动", scale=2)
+                pause_btn = gr.Button("暂停", scale=1)
+
+            # 快速设置控制区域
+            gr.Markdown("### 快速设置")
+
+            with gr.Row():
+                select_all_btn = gr.Button("全选", scale=1)
+                unselect_all_btn = gr.Button("清空", scale=1)
+                select_produce_only_btn = gr.Button("只选培育", scale=1)
+                unselect_produce_only_btn = gr.Button("只不选培育", scale=1)
+
+            with gr.Row(elem_classes=["quick-controls-row"]):
+                purchase_quick = gr.Checkbox(
+                    label="商店",
+                    value=self.current_config.options.purchase.enabled,
+                    interactive=True,
+                    elem_classes=["quick-checkbox"]
+                )
+                assignment_quick = gr.Checkbox(
+                    label="工作",
+                    value=self.current_config.options.assignment.enabled,
+                    interactive=True,
+                    elem_classes=["quick-checkbox"]
+                )
+                contest_quick = gr.Checkbox(
+                    label="竞赛",
+                    value=self.current_config.options.contest.enabled,
+                    interactive=True,
+                    elem_classes=["quick-checkbox"]
+                )
+                produce_quick = gr.Checkbox(
+                    label="培育",
+                    value=self.current_config.options.produce.enabled,
+                    interactive=True,
+                    elem_classes=["quick-checkbox"]
+                )
+                mission_reward_quick = gr.Checkbox(
+                    label="任务",
+                    value=self.current_config.options.mission_reward.enabled,
+                    interactive=True,
+                    elem_classes=["quick-checkbox"]
+                )
+                club_reward_quick = gr.Checkbox(
+                    label="社团",
+                    value=self.current_config.options.club_reward.enabled,
+                    interactive=True,
+                    elem_classes=["quick-checkbox"]
+                )
+                activity_funds_quick = gr.Checkbox(
+                    label="活动费",
+                    value=self.current_config.options.activity_funds.enabled,
+                    interactive=True,
+                    elem_classes=["quick-checkbox"]
+                )
+                presents_quick = gr.Checkbox(
+                    label="礼物",
+                    value=self.current_config.options.presents.enabled,
+                    interactive=True,
+                    elem_classes=["quick-checkbox"]
+                )
+                capsule_toys_quick = gr.Checkbox(
+                    label="扭蛋",
+                    value=self.current_config.options.capsule_toys.enabled,
+                    interactive=True,
+                    elem_classes=["quick-checkbox"]
+                )
+                upgrade_support_card_quick = gr.Checkbox(
+                    label="支援卡",
+                    value=self.current_config.options.upgrade_support_card.enabled,
+                    interactive=True,
+                    elem_classes=["quick-checkbox"]
+                )
+
+            def _get_end_action_value() -> str:
+                if self.current_config.options.end_game.shutdown:
+                    return "关机"
+                if self.current_config.options.end_game.hibernate:
+                    return "休眠"
+                return "什么都不做"
+
+            end_action_dropdown = gr.Dropdown(
+                label="完成后：",
+                choices=["什么都不做", "关机", "休眠"],
+                value=_get_end_action_value(),
+                interactive=True
+            )
+
+            if self._kaa.upgrade_msg:
+                gr.Markdown('### 配置升级报告')
+                gr.Markdown(self._kaa.upgrade_msg)
+            gr.Markdown('脚本报错或者卡住？前往"反馈"选项卡可以快速导出报告！')
+
+            # 添加调试模式警告
+            if self.current_config.keep_screenshots:
+                gr.Markdown(
+                    '<div style="color: red; font-size: larger;">当前启用了调试功能「保留截图数据」，调试结束后正常使用时建议关闭此选项！</div>',
+                    elem_classes=["debug-warning"]
+                )
+
+            task_status = gr.Dataframe(
+                headers=["任务", "状态"],
+                value=self.update_task_status(),
+                label="任务状态"
+            )
+
+            # MARK: 状态 - 监听函数
+
+            def on_run_click(evt: gr.EventData) -> Tuple[gr.Button, List[List[str]]]:
+                result = self.toggle_run()
+                # 如果正在停止，禁用按钮
+                interactive = not self.is_stopping
+                button = gr.Button(value=result[0], interactive=interactive)
+                return button, result[1]
+
+            def on_pause_click(evt: gr.EventData) -> str:
+                return self.toggle_pause()
+
+            # 快速设置控制的事件处理函数
+            def save_quick_setting(success_msg: str, failed_msg: str):
+                """保存快速设置并立即应用"""
+                try:
+                    # 保存配置
+                    save_config(self.config, "config.json")
+
+                    # 尝试热重载配置
+                    if self.reload_config():
+                        gr.Success(success_msg)
+                    else:
+                        gr.Warning(failed_msg)
+                except Exception as e:
+                    gr.Error(f"✗ 保存失败：{str(e)}")
+            
+            def update_and_save_quick_setting(field_name: str, value: bool, display_name: str):
+                """更新字段，并保存快速设置并立即应用"""
+
+                # 更新配置
+                if field_name == 'purchase':
+                    self.current_config.options.purchase.enabled = value
+                elif field_name == 'assignment':
+                    self.current_config.options.assignment.enabled = value
+                elif field_name == 'contest':
+                    self.current_config.options.contest.enabled = value
+                elif field_name == 'produce':
+                    self.current_config.options.produce.enabled = value
+                elif field_name == 'mission_reward':
+                    self.current_config.options.mission_reward.enabled = value
+                elif field_name == 'club_reward':
+                    self.current_config.options.club_reward.enabled = value
+                elif field_name == 'activity_funds':
+                    self.current_config.options.activity_funds.enabled = value
+                elif field_name == 'presents':
+                    self.current_config.options.presents.enabled = value
+                elif field_name == 'capsule_toys':
+                    self.current_config.options.capsule_toys.enabled = value
+                elif field_name == 'upgrade_support_card':
+                    self.current_config.options.upgrade_support_card.enabled = value
+                
+                # 保存并重载配置
+                save_quick_setting(
+                    f"✓ {display_name} 已{'启用' if value else '禁用'}",
+                    f"⚠ {display_name} 已保存，但重新加载失败"
+                )
+
+            def batch_select(default: bool, produce_only: bool, success_msg: str) -> None:
+                self.current_config.options.purchase.enabled             = default
+                self.current_config.options.assignment.enabled           = default
+                self.current_config.options.contest.enabled              = default
+                self.current_config.options.produce.enabled              = produce_only
+                self.current_config.options.mission_reward.enabled       = default
+                self.current_config.options.club_reward.enabled          = default
+                self.current_config.options.activity_funds.enabled       = default
+                self.current_config.options.presents.enabled             = default
+                self.current_config.options.capsule_toys.enabled         = default
+                self.current_config.options.upgrade_support_card.enabled = default
+
+                save_quick_setting(success_msg, f"⚠ 数据已保存，但重新加载失败")
+
+            # MARK: 状态 - UI回调函数
+
+            run_btn.click(
+                fn=on_run_click,
+                outputs=[run_btn, task_status]
+            )
+
+            pause_btn.click(
+                fn=on_pause_click,
+                outputs=[pause_btn]
+            )
+
+            select_all_btn.click(
+                fn=lambda: batch_select(True, True, f"✓ 全选成功"),
+                outputs=[]
+            )
+
+            unselect_all_btn.click(
+                fn=lambda: batch_select(False, False, f"✓ 清空成功"),
+                outputs=[]
+            )
+
+            select_produce_only_btn.click(
+                fn=lambda: batch_select(False, True, f"✓ 只选培育成功"),
+                outputs=[]
+            )
+
+            unselect_produce_only_btn.click(
+                fn=lambda: batch_select(True, False, f"✓ 只不选培育成功"),
+                outputs=[]
+            )
+
+            # 绑定快速设置控制的事件
+
+            # 以下回调函数均由.change修改为.input，这样回调函数就只会在用户操作时触发，避免全选功能导致反复触发
+            purchase_quick.input(
+                fn=lambda x: update_and_save_quick_setting('purchase', x, '商店'),
+                inputs=[purchase_quick]
+            )
+            assignment_quick.input(
+                fn=lambda x: update_and_save_quick_setting('assignment', x, '工作'),
+                inputs=[assignment_quick]
+            )
+            contest_quick.input(
+                fn=lambda x: update_and_save_quick_setting('contest', x, '竞赛'),
+                inputs=[contest_quick]
+            )
+            produce_quick.input(
+                fn=lambda x: update_and_save_quick_setting('produce', x, '培育'),
+                inputs=[produce_quick]
+            )
+            mission_reward_quick.input(
+                fn=lambda x: update_and_save_quick_setting('mission_reward', x, '任务奖励'),
+                inputs=[mission_reward_quick]
+            )
+            club_reward_quick.input(
+                fn=lambda x: update_and_save_quick_setting('club_reward', x, '社团奖励'),
+                inputs=[club_reward_quick]
+            )
+            activity_funds_quick.input(
+                fn=lambda x: update_and_save_quick_setting('activity_funds', x, '活动费'),
+                inputs=[activity_funds_quick]
+            )
+            presents_quick.input(
+                fn=lambda x: update_and_save_quick_setting('presents', x, '礼物'),
+                inputs=[presents_quick]
+            )
+            capsule_toys_quick.input(
+                fn=lambda x: update_and_save_quick_setting('capsule_toys', x, '扭蛋'),
+                inputs=[capsule_toys_quick]
+            )
+            upgrade_support_card_quick.input(
+                fn=lambda x: update_and_save_quick_setting('upgrade_support_card', x, '支援卡升级'),
+                inputs=[upgrade_support_card_quick]
+            )
+
+            # 处理完成后操作下拉框
+            def save_quick_end_action(action: str):
+                try:
+                    if action == "关机":
+                        self.current_config.options.end_game.shutdown = True
+                        self.current_config.options.end_game.hibernate = False
+                    elif action == "休眠":
+                        self.current_config.options.end_game.shutdown = False
+                        self.current_config.options.end_game.hibernate = True
+                    else:  # 什么都不做
+                        self.current_config.options.end_game.shutdown = False
+                        self.current_config.options.end_game.hibernate = False
+
+                    save_config(self.config, "config.json")
+
+                    # 尝试热重载配置
+                    if self.reload_config():
+                        gr.Success(f"✓ 完成后操作已设置为 {action}")
+                    else:
+                        gr.Warning("⚠ 设置已保存，但重新加载失败")
+                except Exception as e:
+                    gr.Error(f"✗ 保存失败：{str(e)}")
+
+            end_action_dropdown.change(
+                fn=save_quick_end_action,
+                inputs=[end_action_dropdown]
+            )
+
+            # 添加定时器，分别更新按钮状态和任务状态
+            def update_run_button_status():
+                text, interactive = self.get_button_status()
+                return gr.Button(value=text, interactive=interactive)
+
+            def update_quick_checkboxes():
+                """更新快速设置区域控件的状态，确保与设置同步"""
+                end_action_val = _get_end_action_value()
+                return [
+                    gr.Checkbox(value=self.current_config.options.purchase.enabled),
+                    gr.Checkbox(value=self.current_config.options.assignment.enabled),
+                    gr.Checkbox(value=self.current_config.options.contest.enabled),
+                    gr.Checkbox(value=self.current_config.options.produce.enabled),
+                    gr.Checkbox(value=self.current_config.options.mission_reward.enabled),
+                    gr.Checkbox(value=self.current_config.options.club_reward.enabled),
+                    gr.Checkbox(value=self.current_config.options.activity_funds.enabled),
+                    gr.Checkbox(value=self.current_config.options.presents.enabled),
+                    gr.Checkbox(value=self.current_config.options.capsule_toys.enabled),
+                    gr.Checkbox(value=self.current_config.options.upgrade_support_card.enabled),
+                    gr.Dropdown(value=end_action_val),
+                ]
+
+            gr.Timer(1.0).tick(
+                fn=update_run_button_status,
+                outputs=[run_btn]
+            )
+            gr.Timer(1.0).tick(
+                fn=self.get_pause_button_with_interactive,
+                outputs=[pause_btn]
+            )
+            gr.Timer(2.0).tick(
+                fn=update_quick_checkboxes,
+                outputs=[
+                    purchase_quick, assignment_quick, contest_quick, produce_quick,
+                    mission_reward_quick, club_reward_quick, activity_funds_quick, presents_quick,
+                    capsule_toys_quick, upgrade_support_card_quick, end_action_dropdown
+                ]
+            )
+            gr.Timer(1.0).tick(
+                fn=self.update_task_status,
+                outputs=[task_status]
+            )
+
+    def _create_task_tab(self) -> None:
+        with gr.Tab("任务"):
+            gr.Markdown("## 执行任务")
+
+            # 第一行：统一的停止和暂停按钮
+            with gr.Row():
+                stop_all_btn = gr.Button("停止任务", variant="stop", scale=1)
+                pause_btn = gr.Button("暂停", scale=1)
+            
+            task_result = gr.Markdown("")
+
+            # 获取所有任务并创建列表布局
+            tasks = list(task_registry.values())
+            task_buttons = []  # 存储所有任务按钮的引用
+            
+            # 为每个任务创建一行：左侧启动按钮，右侧任务名
+            for task in tasks:
+                with gr.Row():
+                    with gr.Column(scale=1, min_width=50):
+                        task_btn = gr.Button("启动", variant="primary", size="sm")
+                        task_buttons.append((task_btn, task.name))
+                    with gr.Column(scale=7):
+                        gr.Markdown(f"{task.name}")
+
+            # 事件处理函数
+            def start_single_task_by_name(task_name: str):
+                """启动指定任务并返回状态信息及所有按钮的更新状态"""
+                if self.single_task_running:
+                    return ["已有任务正在运行"] + [gr.Button(interactive=False) for _ in task_buttons]
+                
+                # 启动任务
+                result = self.start_single_task(task_name)
+                status_msg = result[1]
+                
+                # 如果成功启动，禁用所有任务按钮
+                if self.single_task_running:
+                    disabled_buttons = [gr.Button(value="运行中", interactive=False) for _ in task_buttons]
+                else:
+                    disabled_buttons = [gr.Button(value="启动", interactive=True) for _ in task_buttons]
+                
+                return [status_msg] + disabled_buttons
+
+            def stop_all_tasks():
+                """停止所有任务并重置按钮状态"""
+                if not self.single_task_running:
+                    return ["没有正在运行的任务"] + [gr.Button(value="启动", interactive=True) for _ in task_buttons]
+                
+                # 停止任务
+                result = self.stop_single_task()
+                status_msg = result[1]
+                
+                # 如果正在停止中，显示停止中状态
+                if self.is_single_task_stopping:
+                    disabled_buttons = [gr.Button(value="停止中", interactive=False) for _ in task_buttons]
+                else:
+                    disabled_buttons = [gr.Button(value="启动", interactive=True) for _ in task_buttons]
+                
+                return [status_msg] + disabled_buttons
+
+            def get_task_buttons_status() -> List[gr.Button]:
+                """获取所有任务按钮的状态"""
+                if not hasattr(self, 'run_status') or not self.run_status.running:
+                    self.single_task_running = False
+                    self.is_single_task_stopping = False
+                    return [gr.Button(value="启动", interactive=True) for _ in task_buttons]
+
+                if self.is_single_task_stopping:
+                    return [gr.Button(value="停止中", interactive=False) for _ in task_buttons]
+
+                if self.single_task_running:
+                    return [gr.Button(value="运行中", interactive=False) for _ in task_buttons]
+
+                return [gr.Button(value="启动", interactive=True) for _ in task_buttons]
+
+            def get_single_task_status() -> str:
+                """获取任务状态信息"""
+                if not hasattr(self, 'run_status'):
+                    return ""
+
+                if not self.run_status.running and self.single_task_running:
+                    # 任务已结束但状态未更新
+                    self.single_task_running = False
+
+                    # 检查任务状态
+                    for task_status in self.run_status.tasks:
+                        status = task_status.status
+                        task_name = task_status.task.name
+
+                        if status == 'finished':
+                            return f"任务 {task_name} 已完成"
+                        elif status == 'error':
+                            return f"任务 {task_name} 出错"
+                        elif status == 'cancelled':
+                            return f"任务 {task_name} 已取消"
+
+                    return "任务已结束"
+
+                if self.single_task_running:
+                    for task_status in self.run_status.tasks:
+                        if task_status.status == 'running':
+                            return f"正在执行任务: {task_status.task.name}"
+
+                    return "正在准备执行任务..."
+
+                return ""
+
+            def on_pause_click() -> str:
+                return self.toggle_pause()
+
+            # 绑定事件 - 为每个任务按钮绑定点击事件
+            def create_task_handler(task_name: str):
+                """创建任务处理函数，避免闭包问题"""
+                def handler():
+                    return start_single_task_by_name(task_name)
+                return handler
+
+            for task_btn, task_name in task_buttons:
+                task_btn.click(
+                    fn=create_task_handler(task_name),
+                    outputs=[task_result] + [btn for btn, _ in task_buttons]
+                )
+
+            # 绑定停止按钮事件
+            stop_all_btn.click(
+                fn=stop_all_tasks,
+                outputs=[task_result] + [btn for btn, _ in task_buttons]
+            )
+
+            # 绑定暂停按钮事件
+            pause_btn.click(
+                fn=on_pause_click,
+                outputs=[pause_btn]
+            )
+
+            # 添加定时器更新按钮状态和任务状态
+            gr.Timer(1.0).tick(
+                fn=get_task_buttons_status,
+                outputs=[btn for btn, _ in task_buttons]
+            )
+            gr.Timer(1.0).tick(
+                fn=self.get_pause_button_with_interactive,
+                outputs=[pause_btn]
+            )
+            gr.Timer(1.0).tick(
+                fn=get_single_task_status,
+                outputs=[task_result]
+            )
+
+    def _create_emulator_settings(self) -> ConfigBuilderReturnValue:
+        gr.Markdown("### 模拟器设置")
+        current_tab = 0
+
+        def _update_emulator_tab_options(impl_value: str, selected_index: int):
+            nonlocal current_tab
+            current_tab = selected_index
+            choices = ['adb', 'adb_raw', 'uiautomator2', 'windows', 'remote_windows', 'nemu_ipc']
+            if impl_value not in choices:
+                new_value = choices[0]
+            else:
+                new_value = impl_value
+            return new_value
+
+        with gr.Tabs(selected=self.current_config.backend.type):
+            with gr.Tab("MuMu 12 v4.x", id="mumu12") as tab_mumu12:
+                gr.Markdown("已选中 MuMu 12 v4.x 模拟器")
+                mumu_refresh_message = gr.Markdown("<div style='color: red;'>点击下方「刷新」按钮载入信息</div>", visible=True)
+                mumu_instance = gr.Dropdown(
+                    label="选择多开实例",
+                    choices=[],
+                    interactive=True
+                )
+                mumu_refresh_btn = gr.Button("刷新")
+
+                def refresh_mumu_instances():
+                    try:
+                        instances = Mumu12Host.list()
+                        is_mumu12 = self.current_config.backend.type == 'mumu12'
+                        current_id = self.current_config.backend.instance_id if is_mumu12 else None
+                        choices = [(i.name, i.id) for i in instances]
+                        return gr.Dropdown(choices=choices, value=current_id, interactive=True), gr.Markdown(visible=False)
+                    except Exception as e:
+                        logger.exception('Failed to list installed MuMu12')
+                        gr.Error("获取 MuMu12 模拟器列表失败，请升级模拟器到最新版本。若问题依旧，前往 QQ 群、QQ 频道或 Github 反馈 bug。")
+                        return gr.Dropdown(choices=[], interactive=True), gr.Markdown(visible=True)
+
+                mumu_refresh_btn.click(
+                    fn=refresh_mumu_instances,
+                    outputs=[mumu_instance, mumu_refresh_message]
+                )
+
+                # 如果当前是 MuMu 模拟器且有配置的 instance_id，立即加载实例列表
+                if self.current_config.backend.type == 'mumu12' and self.current_config.backend.instance_id:
+                    try:
+                        instances = Mumu12Host.list()
+                        choices = [(i.name, i.id) for i in instances]
+                        mumu_instance.choices = choices
+                        mumu_instance.value = self.current_config.backend.instance_id
+                        mumu_refresh_message.visible = False
+                    except Exception as e:
+                        logger.exception('Failed to auto-load MuMu12 instances')
+
+                mumu_background_mode = gr.Checkbox(
+                    label="MuMu12 模拟器后台保活模式",
+                    value=self.current_config.backend.mumu_background_mode,
+                    info=BackendConfig.model_fields['mumu_background_mode'].description,
+                    interactive=True
+                )
+
+            with gr.Tab("MuMu 12 v5.x", id="mumu12v5") as tab_mumu12v5:
+                gr.Markdown("已选中 MuMu 12 v5.x 模拟器")
+                mumu_refresh_message = gr.Markdown("<div style='color: red;'>点击下方「刷新」按钮载入信息</div>", visible=True)
+                mumu_instance12v5 = gr.Dropdown(
+                    label="选择多开实例",
+                    choices=[],
+                    interactive=True
+                )
+                mumu_refresh_btn = gr.Button("刷新")
+
+                def refresh_mumu12v5_instances():
+                    try:
+                        instances = Mumu12V5Host.list()
+                        is_mumu12v5 = self.current_config.backend.type == 'mumu12v5'
+                        current_id = self.current_config.backend.instance_id if is_mumu12v5 else None
+                        choices = [(i.name, i.id) for i in instances]
+                        return gr.Dropdown(choices=choices, value=current_id, interactive=True), gr.Markdown(visible=False)
+                    except Exception as e:
+                        logger.exception('Failed to list installed MuMu12v5')
+                        gr.Error("获取 MuMu12 模拟器列表失败，请升级模拟器到最新版本。若问题依旧，前往 QQ 群、QQ 频道或 Github 反馈 bug。")
+                        return gr.Dropdown(choices=[], interactive=True), gr.Markdown(visible=True)
+
+                mumu_refresh_btn.click(
+                    fn=refresh_mumu12v5_instances,
+                    outputs=[mumu_instance12v5, mumu_refresh_message]
+                )
+
+                # 如果当前是 MuMu 模拟器且有配置的 instance_id，立即加载实例列表
+                if self.current_config.backend.type == 'mumu12v5' and self.current_config.backend.instance_id:
+                    try:
+                        instances = Mumu12V5Host.list()
+                        choices = [(i.name, i.id) for i in instances]
+                        mumu_instance12v5.choices = choices
+                        mumu_instance12v5.value = self.current_config.backend.instance_id
+                        mumu_refresh_message.visible = False
+                    except Exception as e:
+                        logger.exception('Failed to auto-load MuMu12v5 instances')
+
+                mumu_background_mode = gr.Checkbox(
+                    label="MuMu12v5 模拟器后台保活模式",
+                    value=self.current_config.backend.mumu_background_mode,
+                    info=BackendConfig.model_fields['mumu_background_mode'].description,
+                    interactive=True
+                )
+
+            with gr.Tab("雷电", id="leidian") as tab_leidian:
+                gr.Markdown("已选中雷电模拟器")
+                leidian_refresh_message = gr.Markdown("<div style='color: red;'>点击下方「刷新」按钮载入信息</div>", visible=True)
+                leidian_instance = gr.Dropdown(
+                    label="选择多开实例",
+                    choices=[],
+                    interactive=True
+                )
+                leidian_refresh_btn = gr.Button("刷新")
+
+                def refresh_leidian_instances():
+                    try:
+                        instances = LeidianHost.list()
+                        is_leidian = self.current_config.backend.type == 'leidian'
+                        current_id = self.current_config.backend.instance_id if is_leidian else None
+                        choices = [(i.name, i.id) for i in instances]
+                        return gr.Dropdown(choices=choices, value=current_id, interactive=True), gr.Markdown(visible=False)
+                    except Exception as e:
+                        logger.exception('Failed to list installed Leidian')
+                        gr.Error("获取雷电模拟器列表失败，请前往 QQ 群、QQ 频道或 Github 反馈 bug。")
+                        return gr.Dropdown(choices=[], interactive=True), gr.Markdown(visible=True)
+
+                leidian_refresh_btn.click(
+                    fn=refresh_leidian_instances,
+                    outputs=[leidian_instance, leidian_refresh_message]
+                )
+
+                # 如果当前是雷电模拟器且有配置的 instance_id，立即加载实例列表
+                if self.current_config.backend.type == 'leidian' and self.current_config.backend.instance_id:
+                    try:
+                        instances = LeidianHost.list()
+                        choices = [(i.name, i.id) for i in instances]
+                        leidian_instance.choices = choices
+                        leidian_instance.value = self.current_config.backend.instance_id
+                        leidian_refresh_message.visible = False
+                    except Exception as e:
+                        logger.exception('Failed to auto-load Leidian instances')
+                        # 保持显示刷新提示
+
+            with gr.Tab("自定义", id="custom") as tab_custom:
+                gr.Markdown("已选中自定义模拟器")
+                adb_ip = gr.Textbox(
+                    value=self.current_config.backend.adb_ip,
+                    label="ADB IP 地址",
+                    info=BackendConfig.model_fields['adb_ip'].description,
+                    interactive=True
+                )
+                adb_port = gr.Number(
+                    value=self.current_config.backend.adb_port,
+                    label="ADB 端口",
+                    info=BackendConfig.model_fields['adb_port'].description,
+                    minimum=1,
+                    maximum=65535,
+                    step=1,
+                    interactive=True
+                )
+                check_emulator = gr.Checkbox(
+                    label="检查并启动模拟器",
+                    value=self.current_config.backend.check_emulator,
+                    info=BackendConfig.model_fields['check_emulator'].description,
+                    interactive=True
+                )
+                with gr.Group(visible=self.current_config.backend.check_emulator) as check_emulator_group:
+                    emulator_path = gr.Textbox(
+                        value=self.current_config.backend.emulator_path,
+                        label="模拟器 exe 文件路径",
+                        info=BackendConfig.model_fields['emulator_path'].description,
+                        interactive=True
+                    )
+                    adb_emulator_name = gr.Textbox(
+                        value=self.current_config.backend.adb_emulator_name,
+                        label="ADB 模拟器名称",
+                        info=BackendConfig.model_fields['adb_emulator_name'].description,
+                        interactive=True
+                    )
+                    emulator_args = gr.Textbox(
+                        value=self.current_config.backend.emulator_args,
+                        label="模拟器启动参数",
+                        info=BackendConfig.model_fields['emulator_args'].description,
+                        interactive=True
+                    )
+                check_emulator.change(
+                    fn=lambda x: gr.Group(visible=x),
+                    inputs=[check_emulator],
+                    outputs=[check_emulator_group]
+                )
+
+            with gr.Tab("DMM", id="dmm") as tab_dmm:
+                gr.Markdown("已选中 DMM")
+                gr.Markdown("**暂停快捷键 <kbd>Ctrl</kbd> + <kbd>F4</kbd>，停止快捷键 <kbd>Ctrl</kbd> + <kbd>F3</kbd>**")
+
+        choices = ['adb', 'adb_raw', 'uiautomator2', 'windows', 'remote_windows', 'nemu_ipc']
+        screenshot_impl = gr.Dropdown(
+            choices=choices,
+            value=self.current_config.backend.screenshot_impl,
+            label="截图方法",
+            info=BackendConfig.model_fields['screenshot_impl'].description,
+            interactive=True
+        )
+
+
+        target_screenshot_interval = gr.Number(
+            label="最小截图间隔（秒）",
+            value=self.current_config.backend.target_screenshot_interval,
+            info=BackendConfig.model_fields['target_screenshot_interval'].description,
+            minimum=0,
+            step=0.1,
+            interactive=True
         )
 
-    except Exception:
-        logger.exception("A critical error occurred during application startup.")
-        # If startup fails, display a minimal error UI to the user.
-        with gr.Blocks() as error_blocks:
-            gr.Markdown("# 琴音小助手 启动失败")
-            gr.Markdown(
-                "kaa 在启动时遇到严重错误。\n\n"
-                "请前往 [QQ 群](https://qm.qq.com/q/DFglKikW2s)或 [Github Issues](https://github.com/a-date-na/kotone-auto-assistant/issues) 寻求帮助。"
+        tab_mumu12.select(fn=partial(_update_emulator_tab_options, selected_index=0), inputs=[screenshot_impl], outputs=[screenshot_impl])
+        tab_mumu12v5.select(fn=partial(_update_emulator_tab_options, selected_index=1), inputs=[screenshot_impl], outputs=[screenshot_impl])
+        tab_leidian.select(fn=partial(_update_emulator_tab_options, selected_index=2), inputs=[screenshot_impl], outputs=[screenshot_impl])
+        tab_custom.select(fn=partial(_update_emulator_tab_options, selected_index=3), inputs=[screenshot_impl], outputs=[screenshot_impl])
+        tab_dmm.select(fn=partial(_update_emulator_tab_options, selected_index=4), inputs=[screenshot_impl], outputs=[screenshot_impl])
+
+        # 初值
+        if self.current_config.backend.type == 'mumu12':
+            _update_emulator_tab_options(
+                impl_value=self.current_config.backend.screenshot_impl,
+                selected_index=0
             )
-            gr.Code(traceback.format_exc(), label="Traceback")
+        elif self.current_config.backend.type == 'mumu12v5':
+            _update_emulator_tab_options(
+                impl_value=self.current_config.backend.screenshot_impl,
+                selected_index=1
+            )
+        elif self.current_config.backend.type == 'leidian':
+            _update_emulator_tab_options(
+                impl_value=self.current_config.backend.screenshot_impl,
+                selected_index=2
+            )
+        elif self.current_config.backend.type == 'custom':
+            _update_emulator_tab_options(
+                impl_value=self.current_config.backend.screenshot_impl,
+                selected_index=3
+            )
+        elif self.current_config.backend.type == 'dmm':
+            _update_emulator_tab_options(
+                impl_value=self.current_config.backend.screenshot_impl,
+                selected_index=4
+            )
+        else:
+            gr.Warning(f"未知的模拟器类型：{self.current_config.backend.type}")
+
+        def set_config(_: BaseConfig, data: dict[ConfigKey, Any]) -> None:
+            # current_tab is updated by _update_emulator_tab_options
+            if current_tab == 0:  # Mumu
+                self.current_config.backend.type = 'mumu12'
+                self.current_config.backend.instance_id = data['_mumu_index']
+                self.current_config.backend.mumu_background_mode = data['mumu_background_mode']
+            elif current_tab == 1:  # Mumu12v5
+                self.current_config.backend.type = 'mumu12v5'
+                self.current_config.backend.instance_id = data['_mumu12v5_index']
+                self.current_config.backend.mumu_background_mode = data['mumu_background_mode']
+            elif current_tab == 2:  # Leidian
+                self.current_config.backend.type = 'leidian'
+                self.current_config.backend.instance_id = data['_leidian_index']
+            elif current_tab == 3:  # Custom
+                self.current_config.backend.type = 'custom'
+                self.current_config.backend.instance_id = None
+                self.current_config.backend.adb_ip = data['adb_ip']
+                self.current_config.backend.adb_port = data['adb_port']
+                self.current_config.backend.adb_emulator_name = data['adb_emulator_name']
+                self.current_config.backend.check_emulator = data['check_emulator']
+                self.current_config.backend.emulator_path = data['emulator_path']
+                self.current_config.backend.emulator_args = data['emulator_args']
+            elif current_tab == 4:  # DMM
+                self.current_config.backend.type = 'dmm'
+                self.current_config.backend.instance_id = None  # DMM doesn't use instance_id here
+
+            # Common settings for all backend types
+            self.current_config.backend.screenshot_impl = data['screenshot_method']
+            self.current_config.backend.target_screenshot_interval = data['target_screenshot_interval']
+
+        return set_config, {
+            'adb_ip': adb_ip,
+            'adb_port': adb_port,
+            'screenshot_method': screenshot_impl,
+            'target_screenshot_interval': target_screenshot_interval,
+            'check_emulator': check_emulator,
+            'emulator_path': emulator_path,
+            'adb_emulator_name': adb_emulator_name,
+            'emulator_args': emulator_args,
+            '_mumu_index': mumu_instance,
+            '_leidian_index': leidian_instance,
+            '_mumu12v5_index': mumu_instance12v5,
+            'mumu_background_mode': mumu_background_mode
+        }
+
+    def _create_purchase_settings(self) -> ConfigBuilderReturnValue:
+        with gr.Column():
+            gr.Markdown("### 商店购买设置")
+            purchase_enabled = gr.Checkbox(
+                label="启用商店购买",
+                value=self.current_config.options.purchase.enabled,
+                info=PurchaseConfig.model_fields['enabled'].description
+            )
+            with gr.Group(visible=self.current_config.options.purchase.enabled) as purchase_group:
+                money_enabled = gr.Checkbox(
+                    label="启用金币购买",
+                    value=self.current_config.options.purchase.money_enabled,
+                    info=PurchaseConfig.model_fields['money_enabled'].description
+                )
+
+                # 添加金币商店商品选择
+                money_items = gr.Dropdown(
+                    multiselect=True,
+                    choices=list(DailyMoneyShopItems.all()),
+                    value=self.current_config.options.purchase.money_items,
+                    label="金币商店购买物品",
+                    info=PurchaseConfig.model_fields['money_items'].description
+                )
+
+                money_refresh = gr.Checkbox(
+                    label="每日一次免费刷新金币商店",
+                    value=self.current_config.options.purchase.money_refresh,
+                    info=PurchaseConfig.model_fields['money_refresh'].description
+                )
+
+                ap_enabled = gr.Checkbox(
+                    label="启用AP购买",
+                    value=self.current_config.options.purchase.ap_enabled,
+                    info=PurchaseConfig.model_fields['ap_enabled'].description
+                )
+
+                # 转换枚举值为显示文本
+                selected_items: List[str] = []
+                ap_items_map = {
+                    APShopItems.PRODUCE_PT_UP: "支援强化点数提升",
+                    APShopItems.PRODUCE_NOTE_UP: "笔记数提升",
+                    APShopItems.RECHALLENGE: "重新挑战券",
+                    APShopItems.REGENERATE_MEMORY: "回忆再生成券"
+                }
+                for item_value in self.current_config.options.purchase.ap_items:
+                    item_enum = APShopItems(item_value)
+                    if item_enum in ap_items_map:
+                        selected_items.append(ap_items_map[item_enum])
+
+                ap_items = gr.Dropdown(
+                    multiselect=True,
+                    choices=list(ap_items_map.values()),
+                    value=selected_items,
+                    label="AP商店购买物品",
+                    info=PurchaseConfig.model_fields['ap_items'].description
+                )
+
+            purchase_enabled.change(
+                fn=lambda x: gr.Group(visible=x),
+                inputs=[purchase_enabled],
+                outputs=[purchase_group]
+            )
+        
+        def set_config(config: BaseConfig, data: dict[ConfigKey, Any]) -> None:
+            config.purchase.enabled = data['purchase_enabled']
+            config.purchase.money_enabled = data['money_enabled']
+            config.purchase.money_items = [DailyMoneyShopItems(x) for x in data['money_items']]
+            config.purchase.money_refresh = data['money_refresh']
+            config.purchase.ap_enabled = data['ap_enabled']
+            ap_items_enum: List[Literal[0, 1, 2, 3]] = []
+            ap_items_map: Dict[str, APShopItems] = {
+                "支援强化点数提升": APShopItems.PRODUCE_PT_UP,
+                "笔记数提升": APShopItems.PRODUCE_NOTE_UP,
+                "重新挑战券": APShopItems.RECHALLENGE,
+                "回忆再生成券": APShopItems.REGENERATE_MEMORY
+            }
+            for item in data['ap_items']:
+                if item in ap_items_map:
+                    ap_items_enum.append(ap_items_map[item].value)  # type: ignore
+            config.purchase.ap_items = ap_items_enum
+        
+        return set_config, {
+            'purchase_enabled': purchase_enabled,
+            'money_enabled': money_enabled,
+            'ap_enabled': ap_enabled,
+            'ap_items': ap_items,
+            'money_items': money_items,
+            'money_refresh': money_refresh
+        }
+
+    def _create_work_settings(self) -> ConfigBuilderReturnValue:
+        with gr.Column():
+            gr.Markdown("### 工作设置")
+            assignment_enabled = gr.Checkbox(
+                label="启用工作",
+                value=self.current_config.options.assignment.enabled,
+                info=AssignmentConfig.model_fields['enabled'].description
+            )
+            with gr.Group(visible=self.current_config.options.assignment.enabled) as work_group:
+                with gr.Row():
+                    with gr.Column():
+                        mini_live_reassign = gr.Checkbox(
+                            label="启用重新分配 MiniLive",
+                            value=self.current_config.options.assignment.mini_live_reassign_enabled,
+                            info=AssignmentConfig.model_fields['mini_live_reassign_enabled'].description
+                        )
+                        mini_live_duration = gr.Dropdown(
+                            choices=[4, 6, 12],
+                            value=self.current_config.options.assignment.mini_live_duration,
+                            label="MiniLive 工作时长",
+                            interactive=True,
+                            info=AssignmentConfig.model_fields['mini_live_duration'].description
+                        )
+                    with gr.Column():
+                        online_live_reassign = gr.Checkbox(
+                            label="启用重新分配 OnlineLive",
+                            value=self.current_config.options.assignment.online_live_reassign_enabled,
+                            info=AssignmentConfig.model_fields['online_live_reassign_enabled'].description
+                        )
+                        online_live_duration = gr.Dropdown(
+                            choices=[4, 6, 12],
+                            value=self.current_config.options.assignment.online_live_duration,
+                            label="OnlineLive 工作时长",
+                            interactive=True,
+                            info=AssignmentConfig.model_fields['online_live_duration'].description
+                        )
+
+            assignment_enabled.change(
+                fn=lambda x: gr.Group(visible=x),
+                inputs=[assignment_enabled],
+                outputs=[work_group]
+            )
+        # return assignment_enabled, mini_live_reassign, mini_live_duration, online_live_reassign, online_live_duration
+        def set_config(config: BaseConfig, data: dict[ConfigKey, Any]) -> None:
+            config.assignment.enabled = data['assignment_enabled']
+            config.assignment.mini_live_reassign_enabled = data['mini_live_reassign']
+            config.assignment.mini_live_duration = data['mini_live_duration']
+            config.assignment.online_live_reassign_enabled = data['online_live_reassign']
+            config.assignment.online_live_duration = data['online_live_duration']
+        
+        return set_config, {
+            'assignment_enabled': assignment_enabled,
+            'mini_live_reassign': mini_live_reassign,
+            'mini_live_duration': mini_live_duration,
+            'online_live_reassign': online_live_reassign,
+            'online_live_duration': online_live_duration
+        }
+
+
+    def _create_contest_settings(self) -> ConfigBuilderReturnValue:
+        with gr.Column():
+            gr.Markdown("### 竞赛设置")
+            contest_enabled = gr.Checkbox(
+                label="启用竞赛",
+                value=self.current_config.options.contest.enabled,
+                info=ContestConfig.model_fields['enabled'].description
+            )
+            with gr.Group(visible=self.current_config.options.contest.enabled) as contest_group:
+                select_which_contestant = gr.Dropdown(
+                    choices=[1, 2, 3],
+                    value=self.current_config.options.contest.select_which_contestant,
+                    label="选择第几位竞赛目标",
+                    interactive=True,
+                    info=ContestConfig.model_fields['select_which_contestant'].description
+                )
+
+                when_no_set_choices = [
+                    ("通知我并跳过竞赛", "remind"),
+                    ("提醒我并等待手动编成", "wait"),
+                    ("使用自动编成并提醒我", "auto_set"),
+                    ("使用自动编成", "auto_set_silent")
+                ]
+                when_no_set = gr.Dropdown(
+                    choices=when_no_set_choices,
+                    value=self.current_config.options.contest.when_no_set,
+                    label="竞赛队伍未编成时",
+                    interactive=True,
+                    info=ContestConfig.model_fields['when_no_set'].description
+                )
+            contest_enabled.change(
+                fn=lambda x: gr.Group(visible=x),
+                inputs=[contest_enabled],
+                outputs=[contest_group]
+            )
+        
+        def set_config(config: BaseConfig, data: dict[ConfigKey, Any]) -> None:
+            config.contest.enabled = data['contest_enabled']
+            config.contest.select_which_contestant = data['select_which_contestant']
+            config.contest.when_no_set = data['when_no_set']
+
+        return set_config, {
+            'contest_enabled': contest_enabled,
+            'select_which_contestant': select_which_contestant,
+            'when_no_set': when_no_set
+        }
+
+    def _create_produce_settings(self) -> ConfigBuilderReturnValue:
+        with gr.Column():
+            gr.Markdown("### 培育设置")
+            produce_enabled = gr.Checkbox(
+                label="启用培育",
+                value=self.current_config.options.produce.enabled,
+                info=ProduceConfig.model_fields['enabled'].description
+            )
+
+            with gr.Group(visible=self.current_config.options.produce.enabled) as produce_group:
+                # 培育方案管理区域
+                solution_manager = ProduceSolutionManager()
+                solutions = solution_manager.list()
+                solution_choices = [(f"{sol.name} - {sol.description or '无描述'}", sol.id) for sol in solutions]
+
+                selected_solution_id = self.current_config.options.produce.selected_solution_id
+                solution_dropdown = gr.Dropdown(
+                    choices=solution_choices,
+                    value=selected_solution_id,
+                    label="当前使用的培育方案",
+                    interactive=True
+                )
+
+                produce_count = gr.Number(
+                    minimum=1,
+                    value=self.current_config.options.produce.produce_count,
+                    label="培育次数",
+                    interactive=True,
+                    info=ProduceConfig.model_fields['produce_count'].description
+                )
+
+                produce_timeout_cd = gr.Number(
+                    minimum=20,
+                    value=self.current_config.options.produce.produce_timeout_cd,
+                    label="推荐卡检测用时上限",
+                    interactive=True,
+                    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")],
+                    value=self.current_config.options.produce.enable_fever_month,
+                    info=ProduceConfig.model_fields['enable_fever_month'].description,
+                    interactive=True
+                )
+
+            # 绑定启用状态变化事件
+            def on_produce_enabled_change(enabled):
+                return gr.Group(visible=enabled)
+
+            produce_enabled.change(
+                fn=on_produce_enabled_change,
+                inputs=[produce_enabled],
+                outputs=[produce_group]
+            )
+
+        # 存储设置Tab中的下拉框引用，供培育Tab使用
+        self._settings_solution_dropdown = solution_dropdown
+
+        def set_config(config: BaseConfig, data: dict[ConfigKey, Any]) -> None:
+            config.produce.enabled = data['produce_enabled']
+            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, {
+            'produce_enabled': produce_enabled,
+            '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
+        }
+
+
+    def _create_produce_tab(self) -> None:
+        """创建培育Tab"""
+        with gr.Tab("培育"):
+            gr.Markdown("## 培育管理")
+
+            # 培育方案管理区域
+            solution_manager = ProduceSolutionManager()
+            solutions = solution_manager.list()
+            solution_choices = [(f"{sol.name} - {sol.description or '无描述'}", sol.id) for sol in solutions]
+
+            selected_solution_id = self.current_config.options.produce.selected_solution_id
+            solution_dropdown = gr.Dropdown(
+                choices=solution_choices,
+                value=selected_solution_id,
+                label="选择培育方案",
+                interactive=True
+            )
+
+            # 获取设置Tab中的下拉框引用
+            settings_dropdown = getattr(self, '_settings_solution_dropdown', None)
+
+            with gr.Row():
+                new_solution_btn = gr.Button("新建培育", scale=1)
+                delete_solution_btn = gr.Button("删除当前培育", scale=1)
+
+            # 培育方案详细设置区域
+            with gr.Group() as solution_settings_group:
+                # 获取当前选中的方案数据
+                current_solution = None
+                if selected_solution_id:
+                    try:
+                        current_solution = solution_manager.read(selected_solution_id)
+                    except ProduceSolutionNotFoundError:
+                        pass
+
+                if current_solution is None:
+                    # 如果没有选中方案，隐藏所有设置组件
+                    solution_name = gr.Textbox(label="方案名称", value="", visible=False)
+                    solution_description = gr.Textbox(label="方案描述", value="", visible=False)
+                    # 其他设置组件都设为不可见
+                    produce_mode = gr.Dropdown(
+                        choices=["regular", "pro", "master"],
+                        label="培育模式",
+                        info="进行一次 REGULAR 培育需要 ~30min，进行一次 PRO 培育需要 ~1h（具体视设备性能而定）。",
+                        visible=False
+                    )
+
+                    # 添加偶像选择
+                    idol_choices = []
+                    for idol in IdolCard.all():
+                        if idol.is_another:
+                            idol_choices.append((f'{idol.name}　「{idol.another_name}」', idol.skin_id))
+                        else:
+                            idol_choices.append((f'{idol.name}', idol.skin_id))
+
+                    produce_idols = gr.Dropdown(
+                        choices=idol_choices,
+                        label="选择要培育的偶像",
+                        multiselect=False,
+                        info="要培育偶像的 IdolCardSkin.id。",
+                        visible=False
+                    )
+                    kotone_warning = gr.Markdown(visible=False)
+                    auto_set_memory = gr.Checkbox(
+                        label="自动编成回忆",
+                        info="是否自动编成回忆。此选项优先级高于回忆编成编号。",
+                        visible=False
+                    )
+                    with gr.Group(visible=False) as memory_sets_group:
+                        memory_sets = gr.Dropdown(
+                            choices=[str(i) for i in range(1, 11)],
+                            label="回忆编成编号",
+                            multiselect=False,
+                            info="要使用的回忆编成编号，从 1 开始。",
+                            visible=False
+                        )
+                    auto_set_support = gr.Checkbox(
+                        label="自动编成支援卡",
+                        info="是否自动编成支援卡。此选项优先级高于支援卡编成编号。",
+                        visible=False
+                    )
+                    with gr.Group(visible=False) as support_card_sets_group:
+                        support_card_sets = gr.Dropdown(
+                            choices=[str(i) for i in range(1, 11)],
+                            label="支援卡编成编号",
+                            multiselect=False,
+                            info="要使用的支援卡编成编号，从 1 开始。",
+                            visible=False
+                        )
+                    use_pt_boost = gr.Checkbox(
+                        label="使用支援强化 Pt 提升",
+                        info="是否使用支援强化 Pt 提升。",
+                        visible=False
+                    )
+                    use_note_boost = gr.Checkbox(
+                        label="使用笔记数提升",
+                        info="是否使用笔记数提升。",
+                        visible=False
+                    )
+                    follow_producer = gr.Checkbox(
+                        label="关注租借了支援卡的制作人",
+                        info="是否关注租借了支援卡的制作人。",
+                        visible=False
+                    )
+                    self_study_lesson = gr.Dropdown(
+                        choices=['dance', 'visual', 'vocal'],
+                        label='文化课自习时选项',
+                        info='自习课类型。',
+                        visible=False
+                    )
+                    prefer_lesson_ap = gr.Checkbox(
+                        label="SP 课程优先",
+                        info="优先 SP 课程。启用后，若出现 SP 课程，则会优先执行 SP 课程，而不是推荐课程。若出现多个 SP 课程，随机选择一个。",
+                        visible=False
+                    )
+                    actions_order = gr.Dropdown(
+                        choices=[(action.display_name, action.value) for action in ProduceAction],
+                        label="行动优先级",
+                        info="每一周的行动将会按这里设置的优先级执行。",
+                        multiselect=True,
+                        visible=False
+                    )
+                    recommend_card_detection_mode = gr.Dropdown(
+                        choices=[
+                            (RecommendCardDetectionMode.NORMAL.display_name, RecommendCardDetectionMode.NORMAL.value),
+                            (RecommendCardDetectionMode.STRICT.display_name, RecommendCardDetectionMode.STRICT.value)
+                        ],
+                        label="推荐卡检测模式",
+                        info="推荐卡检测模式。严格模式下，识别速度会降低，但识别准确率会提高。推荐Kotone使用严格模式，其他角色使用正常模式。",
+                        visible=False
+                    )
+                    use_ap_drink = gr.Checkbox(
+                        label="AP 不足时自动使用 AP 饮料",
+                        info="AP 不足时自动使用 AP 饮料",
+                        visible=False
+                    )
+                    skip_commu = gr.Checkbox(
+                        label="检测并跳过交流",
+                        info="检测并跳过交流",
+                        visible=False
+                    )
+                    save_solution_btn = gr.Button("保存培育方案", variant="primary", visible=False)
+                else:
+                    # 显示选中方案的设置
+                    solution_name = gr.Textbox(
+                        label="方案名称",
+                        value=current_solution.name,
+                        interactive=True
+                    )
+                    solution_description = gr.Textbox(
+                        label="方案描述",
+                        value=current_solution.description or "",
+                        interactive=True
+                    )
+
+                    produce_mode = gr.Dropdown(
+                        choices=["regular", "pro", "master"],
+                        value=current_solution.data.mode,
+                        label="培育模式",
+                        info="进行一次 REGULAR 培育需要 ~30min，进行一次 PRO 培育需要 ~1h（具体视设备性能而定）。"
+                    )
+
+                    # 添加偶像选择
+                    idol_choices = []
+                    for idol in IdolCard.all():
+                        if idol.is_another:
+                            idol_choices.append((f'{idol.name}　「{idol.another_name}」', idol.skin_id))
+                        else:
+                            idol_choices.append((f'{idol.name}', idol.skin_id))
+
+                    produce_idols = gr.Dropdown(
+                        choices=idol_choices,
+                        value=current_solution.data.idol,
+                        label="选择要培育的偶像",
+                        multiselect=False,
+                        interactive=True,
+                        info="要培育偶像的 IdolCardSkin.id。"
+                    )
+
+                    has_kotone = bool(current_solution.data.idol and "藤田ことね" in current_solution.data.idol)
+                    is_strict_mode = current_solution.data.recommend_card_detection_mode == RecommendCardDetectionMode.STRICT
+                    kotone_warning = gr.Markdown(
+                        visible=has_kotone and not is_strict_mode,
+                        value="使用「藤田ことね」进行培育时，确保将「推荐卡检测模式」设置为「严格模式」"
+                    )
+
+                    auto_set_memory = gr.Checkbox(
+                        label="自动编成回忆",
+                        value=current_solution.data.auto_set_memory,
+                        info="是否自动编成回忆。此选项优先级高于回忆编成编号。"
+                    )
+
+                    with gr.Group(visible=not current_solution.data.auto_set_memory) as memory_sets_group:
+                        memory_sets = gr.Dropdown(
+                            choices=[str(i) for i in range(1, 21)],  # 最多20个编成位
+                            value=str(current_solution.data.memory_set) if current_solution.data.memory_set else None,
+                            label="回忆编成编号",
+                            multiselect=False,
+                            interactive=True,
+                            info="要使用的回忆编成编号，从 1 开始。"
+                        )
+
+                    auto_set_support = gr.Checkbox(
+                        label="自动编成支援卡",
+                        value=current_solution.data.auto_set_support_card,
+                        info="是否自动编成支援卡。此选项优先级高于支援卡编成编号。"
+                    )
+
+                    with gr.Group(visible=not current_solution.data.auto_set_support_card) as support_card_sets_group:
+                        support_card_sets = gr.Dropdown(
+                            choices=[str(i) for i in range(1, 21)],  # 最多20个编成位
+                            value=str(current_solution.data.support_card_set) if current_solution.data.support_card_set else None,
+                            label="支援卡编成编号",
+                            multiselect=False,
+                            interactive=True,
+                            info="要使用的支援卡编成编号，从 1 开始。"
+                        )
+                    use_pt_boost = gr.Checkbox(
+                        label="使用支援强化 Pt 提升",
+                        value=current_solution.data.use_pt_boost,
+                        info="是否使用支援强化 Pt 提升。"
+                    )
+                    use_note_boost = gr.Checkbox(
+                        label="使用笔记数提升",
+                        value=current_solution.data.use_note_boost,
+                        info="是否使用笔记数提升。"
+                    )
+                    follow_producer = gr.Checkbox(
+                        label="关注租借了支援卡的制作人",
+                        value=current_solution.data.follow_producer,
+                        info="是否关注租借了支援卡的制作人。"
+                    )
+                    self_study_lesson = gr.Dropdown(
+                        choices=['dance', 'visual', 'vocal'],
+                        value=current_solution.data.self_study_lesson,
+                        label='文化课自习时选项',
+                        info='自习课类型。'
+                    )
+                    prefer_lesson_ap = gr.Checkbox(
+                        label="SP 课程优先",
+                        value=current_solution.data.prefer_lesson_ap,
+                        info="优先 SP 课程。启用后，若出现 SP 课程，则会优先执行 SP 课程，而不是推荐课程。若出现多个 SP 课程，随机选择一个。"
+                    )
+                    actions_order = gr.Dropdown(
+                        choices=[(action.display_name, action.value) for action in ProduceAction],
+                        value=[action.value for action in current_solution.data.actions_order],
+                        label="行动优先级",
+                        info="每一周的行动将会按这里设置的优先级执行。",
+                        multiselect=True
+                    )
+                    recommend_card_detection_mode = gr.Dropdown(
+                        choices=[
+                            (RecommendCardDetectionMode.NORMAL.display_name, RecommendCardDetectionMode.NORMAL.value),
+                            (RecommendCardDetectionMode.STRICT.display_name, RecommendCardDetectionMode.STRICT.value)
+                        ],
+                        value=current_solution.data.recommend_card_detection_mode.value,
+                        label="推荐卡检测模式",
+                        info="推荐卡检测模式。严格模式下，识别速度会降低，但识别准确率会提高。推荐Kotone使用严格模式，其他角色使用正常模式。"
+                    )
+                    use_ap_drink = gr.Checkbox(
+                        label="AP 不足时自动使用 AP 饮料",
+                        value=current_solution.data.use_ap_drink,
+                        info="AP 不足时自动使用 AP 饮料"
+                    )
+                    skip_commu = gr.Checkbox(
+                        label="检测并跳过交流",
+                        value=current_solution.data.skip_commu,
+                        info="检测并跳过交流"
+                    )
+
+                    # 添加保存按钮
+                    save_solution_btn = gr.Button("保存培育方案", variant="primary")
+
+            # 添加事件处理
+            def update_kotone_warning(selected_idol, recommend_card_detection_mode):
+                # Handle case where selected_idol is None (no selection)
+                # selected_idol is a single string (skin_id), not a list
+                if selected_idol is None:
+                    has_kotone = False
+                else:
+                    has_kotone = "藤田ことね" in selected_idol
+                is_strict_mode = recommend_card_detection_mode == RecommendCardDetectionMode.STRICT.value
+                return gr.Markdown(visible=has_kotone and not is_strict_mode)
+
+            def on_solution_change(solution_id):
+                """当选择的培育方案改变时，更新所有设置组件"""
+                if not solution_id:
+                    return [
+                        gr.Textbox(value="", visible=False),  # solution_name
+                        gr.Textbox(value="", visible=False),  # solution_description
+                        gr.Dropdown(visible=False),  # produce_mode
+                        gr.Dropdown(visible=False),  # produce_idols
+                        gr.Markdown(visible=False),  # kotone_warning
+                        gr.Checkbox(visible=False),  # auto_set_memory
+                        gr.Group(visible=False),  # memory_sets_group
+                        gr.Dropdown(visible=False),  # memory_sets
+                        gr.Checkbox(visible=False),  # auto_set_support
+                        gr.Group(visible=False),  # support_card_sets_group
+                        gr.Dropdown(visible=False),  # support_card_sets
+                        gr.Checkbox(visible=False),  # use_pt_boost
+                        gr.Checkbox(visible=False),  # use_note_boost
+                        gr.Checkbox(visible=False),  # follow_producer
+                        gr.Dropdown(visible=False),  # self_study_lesson
+                        gr.Checkbox(visible=False),  # prefer_lesson_ap
+                        gr.Dropdown(visible=False),  # actions_order
+                        gr.Dropdown(visible=False),  # recommend_card_detection_mode
+                        gr.Checkbox(visible=False),  # use_ap_drink
+                        gr.Checkbox(visible=False),  # skip_commu
+                        gr.Button(visible=False),  # save_solution_btn
+                    ]
+
+                try:
+                    solution = solution_manager.read(solution_id)
+                    has_kotone = bool(solution.data.idol and "藤田ことね" in solution.data.idol)
+                    is_strict_mode = solution.data.recommend_card_detection_mode == RecommendCardDetectionMode.STRICT
+
+                    return [
+                        gr.Textbox(value=solution.name, visible=True),
+                        gr.Textbox(value=solution.description or "", visible=True),
+                        gr.Dropdown(value=solution.data.mode, visible=True),
+                        gr.Dropdown(value=solution.data.idol, visible=True),
+                        gr.Markdown(visible=has_kotone and not is_strict_mode),
+                        gr.Checkbox(value=solution.data.auto_set_memory, visible=True),
+                        gr.Group(visible=not solution.data.auto_set_memory),
+                        gr.Dropdown(value=str(solution.data.memory_set) if solution.data.memory_set else None, visible=True),
+                        gr.Checkbox(value=solution.data.auto_set_support_card, visible=True),
+                        gr.Group(visible=not solution.data.auto_set_support_card),
+                        gr.Dropdown(value=str(solution.data.support_card_set) if solution.data.support_card_set else None, visible=True),
+                        gr.Checkbox(value=solution.data.use_pt_boost, visible=True),
+                        gr.Checkbox(value=solution.data.use_note_boost, visible=True),
+                        gr.Checkbox(value=solution.data.follow_producer, visible=True),
+                        gr.Dropdown(value=solution.data.self_study_lesson, visible=True),
+                        gr.Checkbox(value=solution.data.prefer_lesson_ap, visible=True),
+                        gr.Dropdown(value=[action.value for action in solution.data.actions_order], visible=True),
+                        gr.Dropdown(value=solution.data.recommend_card_detection_mode.value, visible=True),
+                        gr.Checkbox(value=solution.data.use_ap_drink, visible=True),
+                        gr.Checkbox(value=solution.data.skip_commu, visible=True),
+                        gr.Button(visible=True),  # save_solution_btn
+                    ]
+                except ProduceSolutionNotFoundError:
+                    gr.Warning(f"培育方案 {solution_id} 不存在")
+                    return on_solution_change(None)
+                except Exception as e:
+                    gr.Error(f"加载培育方案失败：{str(e)}")
+                    return on_solution_change(None)
+
+            def on_new_solution():
+                """创建新的培育方案"""
+                try:
+                    new_solution = solution_manager.new("新培育方案")
+                    solution_manager.save(new_solution.id, new_solution)
+
+                    # 重新列出所有方案
+                    solutions = solution_manager.list()
+                    solution_choices = [(f"{sol.name} - {sol.description or '无描述'}", sol.id) for sol in solutions]
+
+                    gr.Success("新培育方案创建成功")
+
+                    # 更新培育 Tab 下拉框并保持设置 Tab 当前选中值
+                    updated_dropdown_produce = gr.Dropdown(choices=solution_choices, value=new_solution.id)
+                    if settings_dropdown is not None:
+                        current_selected = self.current_config.options.produce.selected_solution_id
+                        updated_dropdown_settings = gr.Dropdown(choices=solution_choices, value=current_selected)
+                        return [updated_dropdown_produce, updated_dropdown_settings]
+                    else:
+                        return updated_dropdown_produce
+                except Exception as e:
+                    gr.Error(f"创建培育方案失败：{str(e)}")
+                    if settings_dropdown is not None:
+                        return [gr.Dropdown(), gr.Dropdown()]
+                    else:
+                        return gr.Dropdown()
+
+            def on_delete_solution(solution_id):
+                """删除当前培育方案"""
+                if not solution_id:
+                    gr.Warning("请先选择要删除的培育方案")
+                    if settings_dropdown is not None:
+                        return [gr.Dropdown(), gr.Dropdown()]
+                    else:
+                        return gr.Dropdown()
+
+                # 若尝试删除当前正在使用的培育方案，则拒绝并提示
+                if solution_id == self.current_config.options.produce.selected_solution_id:
+                    gr.Warning("不可删除选中方案。请先在设置中选择其他方案，保存后再删除此方案。")
+                    if settings_dropdown is not None:
+                        return [gr.Dropdown(), gr.Dropdown()]
+                    else:
+                        return gr.Dropdown()
+
+                try:
+                    solution_manager.delete(solution_id)
+
+                    # 重新列出所有方案
+                    solutions = solution_manager.list()
+                    solution_choices = [(f"{sol.name} - {sol.description or '无描述'}", sol.id) for sol in solutions]
+
+                    gr.Success("培育方案删除成功")
+                    # 删除方案后，保持当前培育方案的选择不变
+                    current_selected = self.current_config.options.produce.selected_solution_id
+                    if current_selected not in [sol.id for sol in solutions]:
+                        current_selected = None  # 已不存在
+
+                    updated_dropdown = gr.Dropdown(choices=solution_choices, value=current_selected)
+                    if settings_dropdown is not None:
+                        return [updated_dropdown, updated_dropdown]
+                    else:
+                        return updated_dropdown
+                except Exception as e:
+                    gr.Error(f"删除培育方案失败：{str(e)}")
+                    if settings_dropdown is not None:
+                        return [gr.Dropdown(), gr.Dropdown()]
+                    else:
+                        return gr.Dropdown()
+
+            def on_save_solution(solution_id, name, description, mode, idols, auto_memory, memory_sets,
+                               auto_support, support_card_sets, pt_boost, note_boost, follow_producer, study_lesson, prefer_ap,
+                               actions, detection_mode, ap_drink, skip_commu_val):
+                """保存培育方案"""
+                if not solution_id:
+                    gr.Warning("请先选择要保存的培育方案")
+                    if settings_dropdown is not None:
+                        return [gr.Dropdown(), gr.Dropdown()]
+                    else:
+                        return gr.Dropdown()
+
+                try:
+                    # 构建培育数据
+                    produce_data = ProduceData(
+                        mode=mode,
+                        idol=idols if idols else None,
+                        memory_set=int(memory_sets) if memory_sets else None,
+                        support_card_set=int(support_card_sets) if support_card_sets else None,
+                        auto_set_memory=auto_memory,
+                        auto_set_support_card=auto_support,
+                        use_pt_boost=pt_boost,
+                        use_note_boost=note_boost,
+                        follow_producer=follow_producer,
+                        self_study_lesson=study_lesson,
+                        prefer_lesson_ap=prefer_ap,
+                        actions_order=[ProduceAction(action) for action in actions] if actions else [],
+                        recommend_card_detection_mode=RecommendCardDetectionMode(detection_mode),
+                        use_ap_drink=ap_drink,
+                        skip_commu=skip_commu_val
+                    )
+
+                    # 构建方案对象
+                    solution = ProduceSolution(
+                        id=solution_id,
+                        name=name or "未命名方案",
+                        description=description,
+                        data=produce_data
+                    )
+
+                    # 保存方案
+                    solution_manager.save(solution_id, solution)
+
+                    # 重新列出所有方案（确保没有重复项）
+                    solutions = solution_manager.list()
+                    solution_choices = [(f"{sol.name} - {sol.description or '无描述'}", sol.id) for sol in solutions]
+
+                    gr.Success("培育方案保存成功")
+                    # 根据是否有设置Tab的下拉框来决定返回值
+                    updated_dropdown = gr.Dropdown(choices=solution_choices, value=solution_id)
+                    if settings_dropdown is not None:
+                        return [updated_dropdown, updated_dropdown]
+                    else:
+                        return updated_dropdown
+                except Exception as e:
+                    gr.Error(f"保存培育方案失败：{str(e)}")
+                    if settings_dropdown is not None:
+                        return [gr.Dropdown(), gr.Dropdown()]
+                    else:
+                        return gr.Dropdown()
+
+            # 绑定事件
+            # 为所有控件绑定change事件，无论是否有选中方案
+            auto_set_memory.change(
+                fn=lambda x: gr.Group(visible=not x),
+                inputs=[auto_set_memory],
+                outputs=[memory_sets_group]
+            )
+
+            auto_set_support.change(
+                fn=lambda x: gr.Group(visible=not x),
+                inputs=[auto_set_support],
+                outputs=[support_card_sets_group]
+            )
+
+            if current_solution is not None:
+                recommend_card_detection_mode.change(
+                    fn=update_kotone_warning,
+                    inputs=[produce_idols, recommend_card_detection_mode],
+                    outputs=kotone_warning
+                )
+                produce_idols.change(
+                    fn=update_kotone_warning,
+                    inputs=[produce_idols, recommend_card_detection_mode],
+                    outputs=kotone_warning
+                )
+
+            # 绑定方案管理事件
+            solution_dropdown.change(
+                fn=on_solution_change,
+                inputs=[solution_dropdown],
+                outputs=[
+                    solution_name, solution_description,
+                    produce_mode, produce_idols, kotone_warning,
+                    auto_set_memory, memory_sets_group, memory_sets,
+                    auto_set_support, support_card_sets_group, support_card_sets,
+                    use_pt_boost, use_note_boost, follow_producer,
+                    self_study_lesson, prefer_lesson_ap, actions_order,
+                    recommend_card_detection_mode, use_ap_drink, skip_commu,
+                    save_solution_btn
+                ]
+            )
+
+            # 准备输出列表，如果设置Tab的下拉框存在，则同时更新
+            outputs_for_new = [solution_dropdown]
+            outputs_for_delete = [solution_dropdown]
+            outputs_for_save = [solution_dropdown]
+
+            if settings_dropdown is not None:
+                outputs_for_new.append(settings_dropdown)
+                outputs_for_delete.append(settings_dropdown)
+                outputs_for_save.append(settings_dropdown)
+
+            new_solution_btn.click(
+                fn=on_new_solution,
+                outputs=outputs_for_new
+            )
+
+            delete_solution_btn.click(
+                fn=on_delete_solution,
+                inputs=[solution_dropdown],
+                outputs=outputs_for_delete
+            )
+
+            # 绑定保存按钮事件
+            save_solution_btn.click(
+                fn=on_save_solution,
+                inputs=[
+                    solution_dropdown, solution_name, solution_description,
+                    produce_mode, produce_idols,
+                    auto_set_memory, memory_sets, auto_set_support, support_card_sets,
+                    use_pt_boost, use_note_boost, follow_producer,
+                    self_study_lesson, prefer_lesson_ap, actions_order,
+                    recommend_card_detection_mode, use_ap_drink, skip_commu
+                ],
+                outputs=outputs_for_save
+            )
+
+    def _create_club_reward_settings(self) -> ConfigBuilderReturnValue:
+        with gr.Column():
+            gr.Markdown("### 社团奖励设置")
+            club_reward_enabled = gr.Checkbox(
+                label="启用社团奖励",
+                value=self.current_config.options.club_reward.enabled,
+                info=ClubRewardConfig.model_fields['enabled'].description
+            )
+            with gr.Group(visible=self.current_config.options.club_reward.enabled) as club_reward_group:
+                selected_note = gr.Dropdown(
+                    choices=list(DailyMoneyShopItems.note_items()),
+                    value=self.current_config.options.club_reward.selected_note,
+                    label="想在社团奖励中获取到的笔记",
+                    interactive=True,
+                    info=ClubRewardConfig.model_fields['selected_note'].description
+                )
+            club_reward_enabled.change(
+                fn=lambda x: gr.Group(visible=x),
+                inputs=[club_reward_enabled],
+                outputs=[club_reward_group]
+            )
+        
+        def set_config(config: BaseConfig, data: dict[ConfigKey, Any]) -> None:
+            config.club_reward.enabled = data['club_reward_enabled']
+            config.club_reward.selected_note = DailyMoneyShopItems(data['selected_note'])
+        
+        return set_config, {
+            'club_reward_enabled': club_reward_enabled,
+            'selected_note': selected_note
+        }
+
+    def _create_capsule_toys_settings(self) -> ConfigBuilderReturnValue:
+        with gr.Column():
+            gr.Markdown("### 扭蛋设置")
+            capsule_toys_enabled = gr.Checkbox(
+                label="是否启用自动扭蛋机",
+                value=self.current_config.options.capsule_toys.enabled,
+                info=CapsuleToysConfig.model_fields['enabled'].description
+            )
+            min_value = 0
+            max_value = 10
+            with gr.Group(visible=self.current_config.options.capsule_toys.enabled) as capsule_toys_group:
+                friend_capsule_toys_count = gr.Number(
+                    value=self.current_config.options.capsule_toys.friend_capsule_toys_count,
+                    label="好友扭蛋机的扭蛋次数",
+                    info=CapsuleToysConfig.model_fields['friend_capsule_toys_count'].description,
+                    minimum=0,
+                    maximum=5
+                )
+                sense_capsule_toys_count = gr.Number(
+                    value=self.current_config.options.capsule_toys.sense_capsule_toys_count,
+                    label="感性扭蛋机的扭蛋次数",
+                    info=CapsuleToysConfig.model_fields['sense_capsule_toys_count'].description,
+                    minimum=0,
+                    maximum=5
+                )
+                logic_capsule_toys_count = gr.Number(
+                    value=self.current_config.options.capsule_toys.logic_capsule_toys_count,
+                    label="逻辑扭蛋机的扭蛋次数",
+                    info=CapsuleToysConfig.model_fields['logic_capsule_toys_count'].description,
+                    minimum=0,
+                    maximum=5
+                )
+                anomaly_capsule_toys_count = gr.Number(
+                    value=self.current_config.options.capsule_toys.anomaly_capsule_toys_count,
+                    label="非凡扭蛋机的扭蛋次数",
+                    info=CapsuleToysConfig.model_fields['anomaly_capsule_toys_count'].description,
+                    minimum=0,
+                    maximum=5
+                )
+            capsule_toys_enabled.change(
+                fn=lambda x: gr.Group(visible=x),
+                inputs=[capsule_toys_enabled],
+                outputs=[capsule_toys_group]
+            )
+        
+        def set_config(config: BaseConfig, data: dict[ConfigKey, Any]) -> None:
+            config.capsule_toys.enabled = data['capsule_toys_enabled']
+            config.capsule_toys.friend_capsule_toys_count = data['friend_capsule_toys_count']
+            config.capsule_toys.sense_capsule_toys_count = data['sense_capsule_toys_count']
+            config.capsule_toys.logic_capsule_toys_count = data['logic_capsule_toys_count']
+            config.capsule_toys.anomaly_capsule_toys_count = data['anomaly_capsule_toys_count']
+        
+        return set_config, {
+            'capsule_toys_enabled': capsule_toys_enabled,
+            'friend_capsule_toys_count': friend_capsule_toys_count,
+            'sense_capsule_toys_count': sense_capsule_toys_count,
+            'logic_capsule_toys_count': logic_capsule_toys_count,
+            'anomaly_capsule_toys_count': anomaly_capsule_toys_count
+        }
+
+
+    def _create_start_game_settings(self) -> ConfigBuilderReturnValue:
+        with gr.Column():
+            gr.Markdown("### 启动游戏设置")
+            start_game_enabled = gr.Checkbox(
+                label="是否启用 自动启动游戏",
+                value=self.current_config.options.start_game.enabled,
+                info=StartGameConfig.model_fields['enabled'].description
+            )
+            with gr.Group(visible=self.current_config.options.start_game.enabled) as start_game_group:
+                start_through_kuyo = gr.Checkbox(
+                    label="是否通过Kuyo启动游戏",
+                    value=self.current_config.options.start_game.start_through_kuyo,
+                    info=StartGameConfig.model_fields['start_through_kuyo'].description
+                )
+                game_package_name = gr.Textbox(
+                    value=self.current_config.options.start_game.game_package_name,
+                    label="游戏包名",
+                    info=StartGameConfig.model_fields['game_package_name'].description
+                )
+                kuyo_package_name = gr.Textbox(
+                    value=self.current_config.options.start_game.kuyo_package_name,
+                    label="Kuyo包名",
+                    info=StartGameConfig.model_fields['kuyo_package_name'].description
+                )
+                disable_gakumas_localify = gr.Checkbox(
+                    label="禁用 Gakumas Localify 汉化插件",
+                    value=self.current_config.options.start_game.disable_gakumas_localify,
+                    info=StartGameConfig.model_fields['disable_gakumas_localify'].description
+                )
+                dmm_game_path = gr.Textbox(
+                    value=self.current_config.options.start_game.dmm_game_path or "",
+                    label="DMM 版游戏路径",
+                    info=StartGameConfig.model_fields['dmm_game_path'].description,
+                    placeholder="例：F:\\Games\\gakumas\\gakumas.exe"
+                )
+                dmm_bypass = gr.Checkbox(
+                    label="绕过 DMM 启动器直接启动游戏（实验性）",
+                    value=self.current_config.options.start_game.dmm_bypass,
+                    info=StartGameConfig.model_fields['dmm_bypass'].description
+                )
+            start_game_enabled.change(
+                fn=lambda x: gr.Group(visible=x),
+                inputs=[start_game_enabled],
+                outputs=[start_game_group]
+            )
+        
+        def set_config(config: BaseConfig, data: dict[ConfigKey, Any]) -> None:
+            config.start_game.enabled = data['start_game_enabled']
+            config.start_game.start_through_kuyo = data['start_through_kuyo']
+            config.start_game.game_package_name = data['game_package_name']
+            config.start_game.kuyo_package_name = data['kuyo_package_name']
+            config.start_game.disable_gakumas_localify = data['disable_gakumas_localify']
+            config.start_game.dmm_game_path = data['dmm_game_path'] if data['dmm_game_path'] else None
+            config.start_game.dmm_bypass = data['dmm_bypass']
+
+        return set_config, {
+            'start_game_enabled': start_game_enabled,
+            'start_through_kuyo': start_through_kuyo,
+            'game_package_name': game_package_name,
+            'kuyo_package_name': kuyo_package_name,
+            'disable_gakumas_localify': disable_gakumas_localify,
+            'dmm_game_path': dmm_game_path,
+            'dmm_bypass': dmm_bypass
+        }
+
+
+    def _create_end_game_settings(self) -> ConfigBuilderReturnValue:
+        with gr.Column():
+            gr.Markdown("### 关闭游戏设置")
+            gr.Markdown("在所有任务执行完毕后执行下面这些操作：\n（执行单个任务时不会触发）")
+            exit_kaa = gr.Checkbox(
+                label="退出 kaa",
+                value=self.current_config.options.end_game.exit_kaa,
+                info=EndGameConfig.model_fields['exit_kaa'].description
+            )
+            kill_game = gr.Checkbox(
+                label="关闭游戏",
+                value=self.current_config.options.end_game.kill_game,
+                info=EndGameConfig.model_fields['kill_game'].description
+            )
+            kill_dmm = gr.Checkbox(
+                label="关闭 DMM",
+                value=self.current_config.options.end_game.kill_dmm,
+                info=EndGameConfig.model_fields['kill_dmm'].description
+            )
+            kill_emulator = gr.Checkbox(
+                label="关闭模拟器",
+                value=self.current_config.options.end_game.kill_emulator,
+                info=EndGameConfig.model_fields['kill_emulator'].description
+            )
+            shutdown = gr.Checkbox(
+                label="关闭系统",
+                value=self.current_config.options.end_game.shutdown,
+                info=EndGameConfig.model_fields['shutdown'].description
+            )
+            hibernate = gr.Checkbox(
+                label="休眠系统",
+                value=self.current_config.options.end_game.hibernate,
+                info=EndGameConfig.model_fields['hibernate'].description
+            )
+            restore_gakumas_localify = gr.Checkbox(
+                label="恢复 Gakumas Localify 汉化插件状态",
+                value=self.current_config.options.end_game.restore_gakumas_localify,
+                info=EndGameConfig.model_fields['restore_gakumas_localify'].description
+            )
+        
+        def set_config(config: BaseConfig, data: dict[ConfigKey, Any]) -> None:
+            config.end_game.exit_kaa = data['exit_kaa']
+            config.end_game.kill_game = data['kill_game']
+            config.end_game.kill_dmm = data['kill_dmm']
+            config.end_game.kill_emulator = data['kill_emulator']
+            config.end_game.shutdown = data['shutdown']
+            config.end_game.hibernate = data['hibernate']
+            config.end_game.restore_gakumas_localify = data['restore_gakumas_localify']
+
+        return set_config, {
+            'exit_kaa': exit_kaa,
+            'kill_game': kill_game,
+            'kill_dmm': kill_dmm,
+            'kill_emulator': kill_emulator,
+            'shutdown': shutdown,
+            'hibernate': hibernate,
+            'restore_gakumas_localify': restore_gakumas_localify
+        }
+
+    def _create_activity_funds_settings(self) -> ConfigBuilderReturnValue:
+        with gr.Column():
+            gr.Markdown("### 活动费设置")
+            activity_funds = gr.Checkbox(
+                label="启用收取活动费",
+                value=self.current_config.options.activity_funds.enabled,
+                info=ActivityFundsConfig.model_fields['enabled'].description
+            )
+        
+        def set_config(config: BaseConfig, data: dict[ConfigKey, Any]) -> None:
+            config.activity_funds.enabled = data['activity_funds']
+        
+        return set_config, {
+            'activity_funds': activity_funds
+        }
+        
+    def _create_presents_settings(self) -> ConfigBuilderReturnValue:
+        with gr.Column():
+            gr.Markdown("### 礼物设置")
+            presents = gr.Checkbox(
+                label="启用收取礼物",
+                value=self.current_config.options.presents.enabled,
+                info=PresentsConfig.model_fields['enabled'].description
+            )
+        
+        def set_config(config: BaseConfig, data: dict[ConfigKey, Any]) -> None:
+            config.presents.enabled = data['presents']
+            
+        return set_config, {
+            'presents': presents
+        }
+        
+    def _create_mission_reward_settings(self) -> ConfigBuilderReturnValue:
+        with gr.Column():
+            gr.Markdown("### 任务奖励设置")
+            mission_reward = gr.Checkbox(
+                label="启用领取任务奖励",
+                value=self.current_config.options.mission_reward.enabled,
+                info=MissionRewardConfig.model_fields['enabled'].description
+            )
+        
+        def set_config(config: BaseConfig, data: dict[ConfigKey, Any]) -> None:
+            config.mission_reward.enabled = data['mission_reward']
+        
+        return set_config, {
+            'mission_reward': mission_reward
+        }
+    
+    def _create_upgrade_support_card_settings(self) -> ConfigBuilderReturnValue:
+        with gr.Column():
+            gr.Markdown("### 升级支援卡设置")
+            upgrade_support_card_enabled = gr.Checkbox(
+                label="启用升级支援卡",
+                value=self.current_config.options.upgrade_support_card.enabled,
+                info=UpgradeSupportCardConfig.model_fields['enabled'].description
+            )
+        
+        def set_config(config: BaseConfig, data: dict[ConfigKey, Any]) -> None:
+            config.upgrade_support_card.enabled = data['upgrade_support_card_enabled']
+        
+        return set_config, {
+            'upgrade_support_card_enabled': upgrade_support_card_enabled
+        }
+        
+    def _create_trace_settings(self) -> ConfigBuilderReturnValue:
+        with gr.Column():
+            gr.Markdown("### 跟踪设置")
+            trace_recommend_card_detection = gr.Checkbox(
+                label="跟踪推荐卡检测",
+                value=self.current_config.options.trace.recommend_card_detection,
+                info=TraceConfig.model_fields['recommend_card_detection'].description,
+                interactive=True
+            )
+        
+        def set_config(config: BaseConfig, data: dict[ConfigKey, Any]) -> None:
+            config.trace.recommend_card_detection = data['trace_recommend_card_detection']
+        
+        return set_config, {
+            'trace_recommend_card_detection': trace_recommend_card_detection
+        }
+
+    def _create_misc_settings(self) -> ConfigBuilderReturnValue:
+        with gr.Column():
+            gr.Markdown("### 杂项设置")
+            check_update = gr.Dropdown(
+                choices=[
+                    ("启动时检查更新", "startup"),
+                    ("从不检查更新", "never")
+                ],
+                value=self.current_config.options.misc.check_update,
+                label="检查更新时机",
+                info=MiscConfig.model_fields['check_update'].description,
+                interactive=True
+            )
+            auto_install_update = gr.Checkbox(
+                label="自动安装更新",
+                value=self.current_config.options.misc.auto_install_update,
+                info=MiscConfig.model_fields['auto_install_update'].description,
+                interactive=True
+            )
+            expose_to_lan = gr.Checkbox(
+                label="允许局域网访问",
+                value=self.current_config.options.misc.expose_to_lan,
+                info=MiscConfig.model_fields['expose_to_lan'].description,
+                interactive=True
+            )
+            update_channel = gr.Dropdown(
+                choices=[
+                    ("正式版", "release"),
+                    ("测试版", "beta")
+                ],
+                value=self.current_config.options.misc.update_channel,
+                label="更新渠道",
+                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),
+                    outputs=[]
+                )
+                gr.Button("创建一键启动快捷方式").click(
+                    fn=self._create_shortcut_button_click(True),
+                    outputs=[]
+                )
+
+        def set_config(config: BaseConfig, data: dict[ConfigKey, Any]) -> None:
+            config.misc.check_update = data['check_update']
+            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,
+            'log_level': log_level
+        }
+
+    def _create_shortcut_button_click(self, start_immediately: bool) -> Callable[[], None]:
+        def _inner():
+            create_desktop_shortcut(start_immediately)
+            gr.Success("快捷方式创建成功")
+        return _inner
+    
+    def _create_idle_settings(self) -> ConfigBuilderReturnValue:
+        with gr.Column():
+            gr.Markdown("### 闲置挂机")
+            idle_enabled = gr.Checkbox(
+                label="启用闲置挂机（任意键暂停、闲置自动恢复）",
+                value=self.current_config.options.idle.enabled,
+                info=IdleModeConfig.model_fields['enabled'].description,
+                interactive=True
+            )
+            idle_seconds = gr.Slider(
+                label="自动恢复触发时间（秒）",
+                minimum=30,
+                maximum=3600,
+                step=10,
+                value=self.current_config.options.idle.idle_seconds,
+                info=IdleModeConfig.model_fields['idle_seconds'].description,
+                interactive=True
+            )
+            idle_minimize_on_pause = gr.Checkbox(
+                label="暂停时最小化游戏窗口",
+                value=self.current_config.options.idle.minimize_on_pause,
+                info=IdleModeConfig.model_fields['minimize_on_pause'].description,
+                interactive=True
+            )
+        
+        def set_config(config: BaseConfig, data: dict[ConfigKey, Any]) -> None:
+            config.idle.enabled = data['idle_enabled']
+            config.idle.idle_seconds = int(data['idle_seconds'])
+            config.idle.minimize_on_pause = data['idle_minimize_on_pause']
+        
+        return set_config, {
+            'idle_enabled': idle_enabled,
+            'idle_seconds': idle_seconds,
+            'idle_minimize_on_pause': idle_minimize_on_pause,
+        }
+
+    def _create_debug_settings(self) -> ConfigBuilderReturnValue:
+        """调试设置：仅在调试时使用"""
+        with gr.Column():
+            gr.Markdown("### 调试设置")
+            gr.Markdown('<div style="color: red;">仅供调试使用。正常运行时务必关闭下面所有的选项。</div>')
+
+            keep_screenshots = gr.Checkbox(
+                label="保留截图数据",
+                value=self.current_config.keep_screenshots,
+                info=UserConfig.model_fields['keep_screenshots'].description,
+                interactive=True
+            )
+
+            trace_recommend_card_detection = gr.Checkbox(
+                label="跟踪推荐卡检测",
+                value=self.current_config.options.trace.recommend_card_detection,
+                info=TraceConfig.model_fields['recommend_card_detection'].description,
+                interactive=True
+            )
+
+        def set_config(config: BaseConfig, data: dict[ConfigKey, Any]) -> None:
+            # 保留截图数据属于 UserConfig
+            self.current_config.keep_screenshots = data['keep_screenshots']
+            # 跟踪推荐卡检测属于 BaseConfig.trace
+            config.trace.recommend_card_detection = data['trace_recommend_card_detection']
+
+        return set_config, {
+            'keep_screenshots': keep_screenshots,
+            'trace_recommend_card_detection': trace_recommend_card_detection
+        }
+
+    def _create_settings_tab(self) -> None:
+        with gr.Tab("设置"):
+            gr.Markdown("## 设置 <span style='color: red; font-size: 0.8rem; font-weight: normal;'>设置修改后需要保存（网页底部）才会生效！</span>")
+
+            # 模拟器设置
+            emulator_settings = self._create_emulator_settings()
+
+            # 商店购买设置
+            purchase_settings = self._create_purchase_settings()
+
+            # 活动费设置
+            activity_funds_settings = self._create_activity_funds_settings()
+
+            # 礼物设置
+            presents_settings = self._create_presents_settings()
+
+            # 工作设置
+            work_settings = self._create_work_settings()
+
+            # 竞赛设置
+            contest_settings = self._create_contest_settings()
+
+            # 培育设置
+            produce_settings = self._create_produce_settings()
+
+            # 任务奖励设置
+            mission_reward_settings = self._create_mission_reward_settings()
+
+            # 社团奖励设置
+            club_reward_settings = self._create_club_reward_settings()
+
+            # 扭蛋设置
+            capsule_toys_settings = self._create_capsule_toys_settings()
+
+            # 升级支援卡设置
+            upgrade_support_card_settings = self._create_upgrade_support_card_settings()
+
+            # 启动游戏设置
+            start_game_settings = self._create_start_game_settings()
+
+            # 关闭游戏设置
+            end_game_settings = self._create_end_game_settings()
+
+            # 杂项设置
+            misc_settings = self._create_misc_settings()
+
+            # 闲置挂机设置
+            idle_settings = self._create_idle_settings()
+
+            # 调试设置（放在最后）
+            debug_settings = self._create_debug_settings()
+
+            save_btn = gr.Button("保存设置")
+            result = gr.Markdown()
+
+            # 收集所有设置组件
+            all_return_values = [
+                emulator_settings,
+                purchase_settings,
+                activity_funds_settings,
+                presents_settings,
+                work_settings,
+                contest_settings,
+                produce_settings,
+                mission_reward_settings,
+                club_reward_settings,
+                capsule_toys_settings,
+                upgrade_support_card_settings,
+                start_game_settings,
+                end_game_settings,
+                misc_settings,
+                idle_settings,
+                debug_settings
+            ] # list of (set_func, { 'key': component, ... })
+            all_components = [list(ret[1].values()) for ret in all_return_values] # [[c1, c2], [c3], ...]
+            all_components = list(chain(*all_components)) # [c1, c2, c3, ...]
+            save_btn.click(
+                fn=partial(self.save_settings2, all_return_values),
+                inputs=all_components,
+                outputs=result
+            )
+
+    def _create_log_tab(self) -> None:
+        with gr.Tab("反馈"):
+            gr.Markdown("## 反馈")
+            gr.Markdown('脚本报错或者卡住？在这里填写信息可以快速反馈！')
+            with gr.Column():
+                report_title = gr.Textbox(label="标题", placeholder="用一句话概括问题")
+                report_type = gr.Dropdown(label="反馈类型", choices=["bug"], value="bug", interactive=False)
+                report_description = gr.Textbox(label="描述", lines=5, placeholder="详细描述问题。例如：什么时候出错、是否每次都出错、出错时的步骤是什么")
+                with gr.Row():
+                    upload_report_btn = gr.Button("上传")
+                    save_local_report_btn = gr.Button("保存至本地")
+
+                result_text = gr.Markdown("等待操作\n\n\n")
+
+            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)
+
+                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=partial(create_report, upload=True),
+                inputs=[report_title, report_description],
+                outputs=[result_text]
+            )
+            save_local_report_btn.click(
+                fn=partial(create_report, upload=False),
+                inputs=[report_title, report_description],
+                outputs=[result_text]
+            )
+
+    def _create_whats_new_tab(self) -> None:
+        """创建更新标签页"""
+        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=[],
+                value=None,
+                visible=False,
+                interactive=True
+            )
+            install_selected_btn = gr.Button("安装选定版本", visible=False)
+
+            def on_load_info():
+                """使用 UpdateService 加载版本信息。"""
+                yield (
+                    "正在载入版本信息...",
+                    gr.Button(value="载入中...", interactive=False),
+                    gr.Dropdown(visible=False),
+                    gr.Button(visible=False)
+                )
+                try:
+                    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
+
+                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:
+                        status_info.append(f"**启动器版本:** v{versions_data.launcher_version}")
+                else:
+                    status_info.append("**启动器版本:** 未知")
+                
+                status_info.append(f"**找到 {len(versions_data.versions)} 个可用版本**")
+                status_message = "\n\n".join(status_info)
+
+                yield (
+                    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)
+                )
+
+            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=on_load_info,
+                outputs=[status_text, load_info_btn, version_dropdown, install_selected_btn]
+            )
+
+            install_selected_btn.click(
+                fn=on_install_selected,
+                inputs=[version_dropdown],
+                outputs=[] 
+            )
+
+    def _load_config(self) -> None:
+        # 加载配置文件
+        config_path = "config.json"
+        self.config = load_config(config_path, type=BaseConfig, use_default_if_not_found=True)
+        if not self.config.user_configs:
+            # 如果没有用户配置，创建一个默认配置
+            default_config = UserConfig[BaseConfig](
+                name="默认配置",
+                category="default",
+                description="默认配置",
+                backend=BackendConfig(),
+                options=BaseConfig()
+            )
+            self.config.user_configs.append(default_config)
+        self.current_config = self.config.user_configs[0]
+
+
+    def create_ui(self) -> gr.Blocks:
+        custom_css = """
+        #container { max-width: 800px; margin: auto; padding: 20px; }
+        .quick-controls-row > div {
+            display: flex !important;
+            flex-wrap: nowrap !important;
+            gap: 0 !important;
+            overflow-x: auto !important;
+        }
+        .quick-controls-row > div > div {
+            min-width: auto !important;
+            padding: 0;
+        }
+        """
+        with gr.Blocks(title="琴音小助手", css=custom_css) as app:
+            with gr.Column(elem_id="container"):
+                gr.Markdown(f"# 琴音小助手 v{self._kaa.version}")
+
+                with gr.Tabs():
+                    self._create_status_tab()
+                    self._create_task_tab()
+                    self._create_settings_tab()
+                    self._create_produce_tab()
+                    self._create_log_tab()
+                    self._create_whats_new_tab()
+
+        # 启动 IdleModeManager 后台线程
+        self.idle_mgr.start()
+
+        return app
+
+def main(kaa: Kaa | None = None, start_immidiately: bool = False) -> None:
+    kaa = kaa or Kaa('./config.json')
+    ui = KotoneBotUI(kaa)
+    app = ui.create_ui()
+
+    if start_immidiately:
+        ui.start_run()
+
+    server_name = "0.0.0.0" if ui.current_config.options.misc.expose_to_lan else "127.0.0.1"
+    app.launch(inbrowser=True, show_error=True, server_name=server_name)
 
-        error_blocks.launch(inbrowser=True)
+if __name__ == "__main__":
+    main()