ksaa 2025.7.5.0__py3-none-any.whl → 2025.7.9.0__py3-none-any.whl

kotonebot/kaa/main/gr.py

@@ -21,12 +21,13 @@ from kotonebot.config.base_config import UserConfig, BackendConfig
 from kotonebot.backend.context import task_registry, ContextStackVars
 from kotonebot.backend.context.context import vars
 from kotonebot.client.host import Mumu12Host, LeidianHost
-from kotonebot.kaa.common import (
+from kotonebot.kaa.config import (
     BaseConfig, APShopItems, CapsuleToysConfig, ClubRewardConfig, PurchaseConfig, ActivityFundsConfig,
     PresentsConfig, AssignmentConfig, ContestConfig, ProduceConfig,
     MissionRewardConfig, DailyMoneyShopItems, ProduceAction,
     RecommendCardDetectionMode, TraceConfig, StartGameConfig, EndGameConfig, UpgradeSupportCardConfig, MiscConfig,
 )
+from kotonebot.kaa.config.produce import ProduceSolution, ProduceSolutionManager, ProduceData
 
 logger = logging.getLogger(__name__)
 GradioInput = gr.Textbox | gr.Number | gr.Checkbox | gr.Dropdown | gr.Radio | gr.Slider | gr.Tabs | gr.Tab
@@ -37,12 +38,12 @@ ConfigKey = Literal[
     'check_emulator', 'emulator_path',
     'adb_emulator_name', 'emulator_args',
     '_mumu_index', '_leidian_index',
-    'mumu_background_mode',
+    'mumu_background_mode', 'target_screenshot_interval',
 
     # purchase
     'purchase_enabled',
     'money_enabled', 'ap_enabled',
-    'ap_items', 'money_items',
+    'ap_items', 'money_items', 'money_refresh',
     
     # assignment
     'assignment_enabled',
@@ -52,14 +53,7 @@ ConfigKey = Literal[
     'select_which_contestant',
     
     # produce
-    'produce_enabled', 'produce_mode',
-    'produce_count', 'produce_idols',
-    'memory_sets', 'auto_set_memory',
-    'auto_set_support', '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',
+    'produce_enabled', 'selected_solution_id', 'produce_count',
     'mission_reward_enabled',
     
     # club reward
@@ -92,8 +86,8 @@ ConfigKey = Literal[
     'trace_recommend_card_detection',
     
     # misc
-    'check_update', 'auto_install_update',
-    
+    'check_update', 'auto_install_update', 'expose_to_lan',
+
     '_selected_backend_index'
     
 ]
@@ -395,6 +389,33 @@ class KotoneBotUI:
         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
+            config.load()
+
+            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 })
@@ -406,45 +427,50 @@ class KotoneBotUI:
             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'],
             '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.idols:
-            gr.Warning("启用培育时，培育偶像不能为空，配置未保存。")
+
+        # 验证规则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")
-            gr.Success("设置已保存，请重启程序！")
+
+            # 尝试热重载配置
+            if self.reload_config():
+                gr.Success("设置已保存并应用！")
+            else:
+                gr.Warning("设置已保存，但重新加载失败，请重启程序。")
             return ""
         except Exception as e:
             gr.Warning(f"保存设置失败：{str(e)}")
@@ -457,11 +483,76 @@ class KotoneBotUI:
             with gr.Row():
                 run_btn = gr.Button("启动", scale=2)
                 pause_btn = gr.Button("暂停", scale=1)
+
+            # 快速功能启停控制区域
+            gr.Markdown("### 快速功能启停")
+            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"]
+                )
+
             if self._kaa.upgrade_msg:
                 gr.Markdown('### 配置升级报告')
                 gr.Markdown(self._kaa.upgrade_msg)
             gr.Markdown('脚本报错或者卡住？前往"反馈"选项卡可以快速导出报告！')
-            
+
             # 添加调试模式警告
             if self.current_config.keep_screenshots:
                 gr.Markdown(
@@ -485,6 +576,45 @@ class KotoneBotUI:
             def on_pause_click(evt: gr.EventData) -> str:
                 return self.toggle_pause()
 
+            # 快速功能控制的事件处理函数
+            def save_quick_setting(field_name: str, value: bool, display_name: str):
+                """保存快速设置并立即应用"""
+                try:
+                    # 更新配置
+                    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
+                    elif field_name == 'start_game':
+                        self.current_config.options.start_game.enabled = value
+
+                    # 保存配置
+                    save_config(self.config, "config.json")
+
+                    # 尝试热重载配置
+                    if self.reload_config():
+                        gr.Success(f"✓ {display_name} 已{'启用' if value else '禁用'}")
+                    else:
+                        gr.Warning(f"⚠ {display_name} 已保存，但重新加载失败")
+                except Exception as e:
+                    gr.Error(f"✗ 保存失败：{str(e)}")
+
             run_btn.click(
                 fn=on_run_click,
                 outputs=[run_btn, task_status]
@@ -495,11 +625,68 @@ class KotoneBotUI:
                 outputs=[pause_btn]
             )
 
+            # 绑定快速功能控制的事件
+            purchase_quick.change(
+                fn=lambda x: save_quick_setting('purchase', x, '商店'),
+                inputs=[purchase_quick]
+            )
+            assignment_quick.change(
+                fn=lambda x: save_quick_setting('assignment', x, '工作'),
+                inputs=[assignment_quick]
+            )
+            contest_quick.change(
+                fn=lambda x: save_quick_setting('contest', x, '竞赛'),
+                inputs=[contest_quick]
+            )
+            produce_quick.change(
+                fn=lambda x: save_quick_setting('produce', x, '培育'),
+                inputs=[produce_quick]
+            )
+            mission_reward_quick.change(
+                fn=lambda x: save_quick_setting('mission_reward', x, '任务奖励'),
+                inputs=[mission_reward_quick]
+            )
+            club_reward_quick.change(
+                fn=lambda x: save_quick_setting('club_reward', x, '社团奖励'),
+                inputs=[club_reward_quick]
+            )
+            activity_funds_quick.change(
+                fn=lambda x: save_quick_setting('activity_funds', x, '活动费'),
+                inputs=[activity_funds_quick]
+            )
+            presents_quick.change(
+                fn=lambda x: save_quick_setting('presents', x, '礼物'),
+                inputs=[presents_quick]
+            )
+            capsule_toys_quick.change(
+                fn=lambda x: save_quick_setting('capsule_toys', x, '扭蛋'),
+                inputs=[capsule_toys_quick]
+            )
+            upgrade_support_card_quick.change(
+                fn=lambda x: save_quick_setting('upgrade_support_card', x, '支援卡升级'),
+                inputs=[upgrade_support_card_quick]
+            )
+
             # 添加定时器，分别更新按钮状态和任务状态
             def update_run_button_status():
                 text, interactive = self.get_button_status()
                 return gr.Button(value=text, interactive=interactive)
 
+            def update_quick_checkboxes():
+                """更新快速功能控制的 checkbox 状态，确保与设置同步"""
+                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.Timer(1.0).tick(
                 fn=update_run_button_status,
                 outputs=[run_btn]
@@ -508,6 +695,14 @@ class KotoneBotUI:
                 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
+                ]
+            )
             gr.Timer(1.0).tick(
                 fn=self.update_task_status,
                 outputs=[task_status]
@@ -761,6 +956,15 @@ class KotoneBotUI:
             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
+        )
+
         tab_mumu12.select(fn=partial(_update_emulator_tab_options, selected_index=0), inputs=[screenshot_impl], outputs=[screenshot_impl])
         tab_leidian.select(fn=partial(_update_emulator_tab_options, selected_index=1), inputs=[screenshot_impl], outputs=[screenshot_impl])
         tab_custom.select(fn=partial(_update_emulator_tab_options, selected_index=2), inputs=[screenshot_impl], outputs=[screenshot_impl])
@@ -814,12 +1018,14 @@ class KotoneBotUI:
 
             # 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']
             self.current_config.keep_screenshots = data['keep_screenshots']  # This is a UserConfig field
 
         return set_config, {
             'adb_ip': adb_ip,
             'adb_port': adb_port,
             'screenshot_method': screenshot_impl,  # screenshot_impl is the component
+            'target_screenshot_interval': target_screenshot_interval,
             'keep_screenshots': keep_screenshots,
             'check_emulator': check_emulator,
             'emulator_path': emulator_path,
@@ -854,6 +1060,12 @@ class KotoneBotUI:
                     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,
@@ -891,6 +1103,7 @@ class KotoneBotUI:
             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] = {
@@ -909,7 +1122,8 @@ class KotoneBotUI:
             'money_enabled': money_enabled,
             'ap_enabled': ap_enabled,
             'ap_items': ap_items,
-            'money_items': money_items
+            'money_items': money_items,
+            'money_refresh': money_refresh
         }
 
     def _create_work_settings(self) -> ConfigBuilderReturnValue:
@@ -1010,13 +1224,21 @@ class KotoneBotUI:
                 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:
-                produce_mode = gr.Dropdown(
-                    choices=["regular", "pro", "master"],
-                    value=self.current_config.options.produce.mode,
-                    label="培育模式",
-                    info=ProduceConfig.model_fields['mode'].description
+                # 培育方案管理区域
+                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,
@@ -1024,106 +1246,523 @@ class KotoneBotUI:
                     interactive=True,
                     info=ProduceConfig.model_fields['produce_count'].description
                 )
-                # 添加偶像选择
-                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))
-                selected_idols = self.current_config.options.produce.idols
-                produce_idols = gr.Dropdown(
-                    choices=idol_choices,
-                    value=selected_idols,
-                    label="选择要培育的偶像",
-                    multiselect=True,
-                    interactive=True,
-                    info=ProduceConfig.model_fields['idols'].description
-                )
-                has_kotone = any("藤田ことね" in idol for idol in selected_idols)
-                is_strict_mode = self.current_config.options.produce.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=self.current_config.options.produce.auto_set_memory,
-                    info=ProduceConfig.model_fields['auto_set_memory'].description
-                )
-                with gr.Group(visible=not self.current_config.options.produce.auto_set_memory) as memory_sets_group:
-                    memory_sets = gr.Dropdown(
-                        choices=[str(i) for i in range(1, 11)],  # 假设最多10个编成位
-                        value=[str(i) for i in self.current_config.options.produce.memory_sets],
-                        label="回忆编成编号",
+
+            # 绑定启用状态变化事件
+            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)
+
+        return set_config, {
+            'produce_enabled': produce_enabled,
+            'selected_solution_id': solution_dropdown,
+            'produce_count': produce_count
+        }
+
+
+    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 FileNotFoundError:
+                        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
+                    )
+                    produce_count = gr.Number(
+                        minimum=1,
+                        label="培育次数",
+                        info="培育的次数。",
+                        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="推荐卡检测模式。严格模式下，识别速度会降低，但识别准确率会提高。",
+                        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（具体视设备性能而定）。"
+                    )
+                    produce_count = gr.Number(
+                        minimum=1,
+                        value=self.current_config.options.produce.produce_count,
+                        label="培育次数",
                         interactive=True,
-                        info=ProduceConfig.model_fields['memory_sets'].description
+                        info="培育的次数。"
                     )
 
-                # 添加偶像选择变化时的回调
-                def update_kotone_warning(selected_idols, recommend_card_detection_mode):
-                    has_kotone = any("藤田ことね" in idol for idol in selected_idols)
-                    is_strict_mode = recommend_card_detection_mode == RecommendCardDetectionMode.STRICT.value
-                    return gr.Markdown(visible=has_kotone and not is_strict_mode)
+                    # 添加偶像选择
+                    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。"
+                    )
 
-                auto_set_support = gr.Checkbox(
-                    label="自动编成支援卡",
-                    value=self.current_config.options.produce.auto_set_support_card,
-                    info=ProduceConfig.model_fields['auto_set_support_card'].description
-                )
-                use_pt_boost = gr.Checkbox(
-                    label="使用支援强化 Pt 提升",
-                    value=self.current_config.options.produce.use_pt_boost,
-                    info=ProduceConfig.model_fields['use_pt_boost'].description
-                )
-                use_note_boost = gr.Checkbox(
-                    label="使用笔记数提升",
-                    value=self.current_config.options.produce.use_note_boost,
-                    info=ProduceConfig.model_fields['use_note_boost'].description
-                )
-                follow_producer = gr.Checkbox(
-                    label="关注租借了支援卡的制作人",
-                    value=self.current_config.options.produce.follow_producer,
-                    info=ProduceConfig.model_fields['follow_producer'].description
-                )
-                self_study_lesson = gr.Dropdown(
-                    choices=['dance', 'visual', 'vocal'],
-                    value=self.current_config.options.produce.self_study_lesson,
-                    label='文化课自习时选项',
-                    info='选择自习课类型'
-                )
-                prefer_lesson_ap = gr.Checkbox(
-                    label="SP 课程优先",
-                    value=self.current_config.options.produce.prefer_lesson_ap,
-                    info=ProduceConfig.model_fields['prefer_lesson_ap'].description
-                )
-                actions_order = gr.Dropdown(
-                    choices=[(action.display_name, action.value) for action in ProduceAction],
-                    value=[action.value for action in self.current_config.options.produce.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=self.current_config.options.produce.recommend_card_detection_mode.value,
-                    label="推荐卡检测模式",
-                    info=ProduceConfig.model_fields['recommend_card_detection_mode'].description
-                )
-                use_ap_drink = gr.Checkbox(
-                    label="AP 不足时自动使用 AP 饮料",
-                    value=self.current_config.options.produce.use_ap_drink,
-                    info=ProduceConfig.model_fields['use_ap_drink'].description
-                )
-                skip_commu = gr.Checkbox(
-                    label="检测并跳过交流",
-                    value=self.current_config.options.produce.skip_commu,
-                    info=ProduceConfig.model_fields['skip_commu'].description
-                )
+                    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, 11)],  # 假设最多10个编成位
+                            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, 11)],  # 假设最多10个编成位
+                            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="推荐卡检测模式。严格模式下，识别速度会降低，但识别准确率会提高。"
+                    )
+                    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.Number(visible=False),  # produce_count
+                        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.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.Number(value=self.current_config.options.produce.produce_count, 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 FileNotFoundError:
+                    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的下拉框来决定返回值
+                    updated_dropdown = gr.Dropdown(choices=solution_choices, value=new_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()
+
+            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()
+
+                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("培育方案删除成功")
+                    # 根据是否有设置Tab的下拉框来决定返回值
+                    updated_dropdown = gr.Dropdown(choices=solution_choices, value=None)
+                    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, count, 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)
+
+                    # 同时更新配置中的 produce_count
+                    self.current_config.options.produce.produce_count = int(count)
+
+                    # 重新列出所有方案（确保没有重复项）
+                    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],
@@ -1135,54 +1774,56 @@ class KotoneBotUI:
                     outputs=kotone_warning
                 )
 
-            produce_enabled.change(
-                fn=lambda x: gr.Group(visible=x),
-                inputs=[produce_enabled],
-                outputs=[produce_group]
+            # 绑定方案管理事件
+            solution_dropdown.change(
+                fn=on_solution_change,
+                inputs=[solution_dropdown],
+                outputs=[
+                    solution_name, solution_description,
+                    produce_mode, produce_count, 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
+                ]
             )
 
-            auto_set_memory.change(
-                fn=lambda x: gr.Group(visible=not x),
-                inputs=[auto_set_memory],
-                outputs=[memory_sets_group]
+            # 准备输出列表，如果设置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_count, 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 set_config(config: BaseConfig, data: dict[ConfigKey, Any]) -> None:
-            config.produce.enabled = data['produce_enabled']
-            config.produce.mode = data['produce_mode']
-            config.produce.produce_count = data['produce_count']
-            config.produce.idols = data['produce_idols']
-            config.produce.memory_sets = [int(i) for i in data['memory_sets']]
-            config.produce.auto_set_memory = data['auto_set_memory']
-            config.produce.auto_set_support_card = data['auto_set_support']
-            config.produce.use_pt_boost = data['use_pt_boost']
-            config.produce.use_note_boost = data['use_note_boost']
-            config.produce.follow_producer = data['follow_producer']
-            config.produce.self_study_lesson = data['self_study_lesson']
-            config.produce.prefer_lesson_ap = data['prefer_lesson_ap']
-            config.produce.actions_order = [ProduceAction(action) for action in data['actions_order']]
-            config.produce.recommend_card_detection_mode = RecommendCardDetectionMode(data['recommend_card_detection_mode'])
-            config.produce.use_ap_drink = data['use_ap_drink']
-            config.produce.skip_commu = data['skip_commu']
-        
-        return set_config, {
-            'produce_enabled': produce_enabled,
-            'produce_mode': produce_mode,
-            'produce_count': produce_count,
-            'produce_idols': produce_idols,
-            'memory_sets': memory_sets,
-            'auto_set_memory': auto_set_memory,
-            'auto_set_support': auto_set_support,
-            'use_pt_boost': use_pt_boost,
-            'use_note_boost': use_note_boost,
-            'follow_producer': follow_producer,
-            'self_study_lesson': self_study_lesson,
-            'prefer_lesson_ap': prefer_lesson_ap,
-            'actions_order': actions_order,
-            'recommend_card_detection_mode': recommend_card_detection_mode,
-            'use_ap_drink': use_ap_drink,
-            'skip_commu': skip_commu
-        }
 
     def _create_club_reward_settings(self) -> ConfigBuilderReturnValue:
         with gr.Column():
@@ -1494,14 +2135,22 @@ class KotoneBotUI:
                 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
+            )
+
         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']
         
         return set_config, {
             'check_update': check_update,
-            'auto_install_update': auto_install_update
+            'auto_install_update': auto_install_update,
+            'expose_to_lan': expose_to_lan
         }
 
     def _create_settings_tab(self) -> None:
@@ -1870,7 +2519,20 @@ class KotoneBotUI:
         self.current_config = self.config.user_configs[0]
 
     def create_ui(self) -> gr.Blocks:
-        with gr.Blocks(title="琴音小助手", css="#container { max-width: 800px; margin: auto; padding: 20px; }") as app:
+        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}")
 
@@ -1878,6 +2540,7 @@ class KotoneBotUI:
                     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()
                     self._create_screen_tab()
@@ -1888,7 +2551,9 @@ def main(kaa: Kaa | None = None) -> None:
     kaa = kaa or Kaa('./config.json')
     ui = KotoneBotUI(kaa)
     app = ui.create_ui()
-    app.launch(inbrowser=True, show_error=True)
+
+    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)
 
 if __name__ == "__main__":
     main()