from flask import Blueprint, render_template, jsonify, request, send_from_directory, current_app, Response from .auth import login_required from loguru import logger import os import time import subprocess from datetime import datetime import platform import psutil from collections import deque import gzip import json import yaml import toml from utils.markdown_to_image import get_md2img_health_snapshot, warmup_md2img_browser_sync from utils.ai.llm_registry import LLMRegistry from base.plugin_common.plugin_interface import PluginStatus from utils.ai.unified_llm import UnifiedLLMClient # 创建系统信息蓝图 system_bp = Blueprint('system', __name__) # 记录应用启动时间 APP_START_TIME = time.time() def _system_config_path() -> str: return os.path.abspath(os.path.join(os.path.dirname(__file__), '..', '..', '..', 'config.yaml')) def _load_system_yaml() -> dict: config_path = _system_config_path() if not os.path.exists(config_path): return {} with open(config_path, 'r', encoding='utf-8') as f: return yaml.safe_load(f) or {} def _save_system_yaml(config_obj: dict) -> None: config_path = _system_config_path() with open(config_path, 'w', encoding='utf-8') as f: yaml.safe_dump(config_obj, f, allow_unicode=True, sort_keys=False) def _legacy_llm_to_catalog(legacy_llm: dict) -> dict: """把旧 llm(backends/scenes) 结构转换为新目录结构（仅用于兜底展示）。 说明： 1. 该转换不写库，只用于当目录表不可用时让后台页面仍可展示； 2. 规则与 DB bootstrap 一致：dify backend 拆成 provider+dify_app，其他保留为 backend。 """ llm = legacy_llm or {} old_backends = llm.get("backends", {}) or {} old_scenes = llm.get("scenes", {}) or {} default_backend = str(llm.get("default_backend") or "").strip() providers = [] dify_apps = [] backends = [] scenes = [] dify_template_cfg = None for backend in old_backends.values(): if isinstance(backend, dict) and str(backend.get("provider") or "").strip().lower() == "dify": dify_template_cfg = dict(backend) break if dify_template_cfg: providers.append( { "name": "dify_workflow_default", "provider_type": "dify", "enabled": True, "config": { "provider": "dify", "api_base_url": dify_template_cfg.get("api_base_url", ""), "endpoint": dify_template_cfg.get("endpoint", "workflows/run"), "mode": dify_template_cfg.get("mode", "workflow"), "response_mode": dify_template_cfg.get("response_mode", "blocking"), "request_timeout": dify_template_cfg.get("request_timeout", 60), "max_retries": dify_template_cfg.get("max_retries", 3), "retry_delay_seconds": dify_template_cfg.get("retry_delay_seconds", 1.0), }, } ) for backend_name, backend_cfg in old_backends.items(): if not isinstance(backend_cfg, dict): continue provider = str(backend_cfg.get("provider") or "").strip().lower() if provider == "dify": dify_apps.append( { "name": str(backend_name), "provider_template": "dify_workflow_default", "app_key": str(backend_cfg.get("api_key") or "").strip(), "workflow_output_key": str(backend_cfg.get("workflow_output_key") or "text").strip(), "enabled": True, "config": { "endpoint": backend_cfg.get("endpoint", ""), "mode": backend_cfg.get("mode", ""), "response_mode": backend_cfg.get("response_mode", ""), "request_timeout": backend_cfg.get("request_timeout", ""), }, } ) else: backends.append( { "name": str(backend_name), "enabled": True, "config": dict(backend_cfg), } ) if isinstance(old_scenes, dict) and old_scenes: for scene_name, backend_name in old_scenes.items(): scene_name = str(scene_name or "").strip() backend_name = str(backend_name or "").strip() if not scene_name or not backend_name: continue backend_cfg = old_backends.get(backend_name, {}) or {} provider = str((backend_cfg or {}).get("provider") or "").strip().lower() scenes.append( { "name": scene_name, "target_type": "dify_app" if provider == "dify" else "backend", "target_ref": backend_name, "enabled": True, } ) elif default_backend: default_cfg = old_backends.get(default_backend, {}) or {} provider = str((default_cfg or {}).get("provider") or "").strip().lower() scenes.append( { "name": "main.default", "target_type": "dify_app" if provider == "dify" else "backend", "target_ref": default_backend, "enabled": True, } ) default_scene = scenes[0]["name"] if scenes else "" return { "default_scene": default_scene, "providers": providers, "dify_apps": dify_apps, "backends": backends, "scenes": scenes, } def _load_llm_catalog_runtime() -> dict: """读取运行时 LLM 目录配置（优先 MySQL 新模型）。""" try: server = current_app.dashboard_server llm_catalog_db = getattr(server, "llm_catalog_db", None) if llm_catalog_db: catalog = llm_catalog_db.get_catalog() or {} if catalog and catalog.get("scenes"): return catalog except Exception as e: logger.warning(f"从 MySQL 读取 LLM 目录失败，回退 YAML: {e}") # 兜底：把 YAML 的 legacy llm 转成目录结构给后台展示。 config_obj = _load_system_yaml() llm_config = config_obj.get("llm", {}) or {} if not isinstance(llm_config, dict): llm_config = {} return _legacy_llm_to_catalog(llm_config) def _save_llm_catalog_runtime(catalog: dict) -> None: """保存运行时 LLM 目录配置到 MySQL。""" server = current_app.dashboard_server llm_catalog_db = getattr(server, "llm_catalog_db", None) if not llm_catalog_db: raise RuntimeError("llm_catalog_db 未初始化，无法保存 LLM 目录到 MySQL") ok = llm_catalog_db.save_catalog(catalog or {}) if not ok: raise RuntimeError("保存 LLM 目录到 MySQL 失败") def _plugins_root_path() -> str: """返回插件根目录绝对路径。""" return os.path.abspath(os.path.join(os.path.dirname(__file__), '..', '..', '..', 'plugins')) def _scan_plugin_llm_usage() -> list: """扫描各插件 config.toml，提取插件与 LLM 场景的引用关系。 说明： 1. 该扫描仅用于后台可视化，不会改写插件配置； 2. 严格模式只采集 scene：顶层 section 写法，或嵌套在 llm/api/report_api 等节点； 3. 返回结果用于“插件 -> scene -> backend”依赖拓扑展示。 """ plugins_root = _plugins_root_path() if not os.path.isdir(plugins_root): return [] usages = [] def _collect_refs(plugin_name: str, section_name: str, payload: dict) -> None: """从单个配置节点收集 scene 引用。""" if not isinstance(payload, dict): return scene_name = str(payload.get("scene") or "").strip() if not scene_name: return usages.append({ "plugin": plugin_name, "section": section_name, "scene": scene_name, }) for item in sorted(os.listdir(plugins_root)): plugin_dir = os.path.join(plugins_root, item) if not os.path.isdir(plugin_dir): continue config_path = os.path.join(plugin_dir, "config.toml") if not os.path.exists(config_path): continue try: config_obj = toml.load(config_path) or {} except Exception as e: logger.warning(f"扫描插件 LLM 依赖失败: plugin={item}, path={config_path}, error={e}") continue # 优先扫描每个 section：兼容 [Dify] / [api] / [Douyu.report_api] 等写法。 for section_name, section_value in config_obj.items(): if isinstance(section_value, dict): _collect_refs(item, str(section_name), section_value) # 二层兜底：处理 llm/api/report_api 等嵌套节点。 for nested_name, nested_value in section_value.items(): if isinstance(nested_value, dict): _collect_refs(item, f"{section_name}.{nested_name}", nested_value) # 顶层兜底：兼容极少数直接写在根节点的 scene。 _collect_refs(item, "__root__", config_obj if isinstance(config_obj, dict) else {}) # 去重：同插件同 section 仅保留一条记录，避免前后兜底重复。 unique = {} for row in usages: key = f"{row.get('plugin')}::{row.get('section')}::{row.get('scene')}" unique[key] = row return sorted(unique.values(), key=lambda x: (x.get("plugin", ""), x.get("section", ""))) def _build_llm_topology() -> dict: """构建 LLM 拓扑视图（供后台页面直观展示依赖关系）。""" catalog = _load_llm_catalog_runtime() providers = {str(item.get("name") or "").strip(): item for item in (catalog.get("providers", []) or [])} dify_apps = {str(item.get("name") or "").strip(): item for item in (catalog.get("dify_apps", []) or [])} backends = {str(item.get("name") or "").strip(): item for item in (catalog.get("backends", []) or [])} scenes = {str(item.get("name") or "").strip(): item for item in (catalog.get("scenes", []) or [])} default_scene = str(catalog.get("default_scene") or "").strip() plugin_usages = _scan_plugin_llm_usage() topology_rows = [] for usage in plugin_usages: scene_name = str(usage.get("scene") or "").strip() scene = scenes.get(scene_name, {}) or {} target_type = str(scene.get("target_type") or "").strip().lower() target_ref = str(scene.get("target_ref") or "").strip() resolved_provider = "" resolved_target = target_ref valid_target = False if target_type == "dify_app": app = dify_apps.get(target_ref, {}) or {} provider_name = str(app.get("provider_template") or "").strip() provider = providers.get(provider_name, {}) or {} resolved_provider = str(provider.get("provider_type") or "").strip() valid_target = bool(app and provider) elif target_type == "backend": backend = backends.get(target_ref, {}) or {} backend_cfg = (backend.get("config") or {}) if isinstance(backend, dict) else {} resolved_provider = str((backend_cfg or {}).get("provider") or "").strip() valid_target = bool(backend) topology_rows.append({ "plugin": usage.get("plugin", ""), "section": usage.get("section", ""), "scene": scene_name, "target_type": target_type or "-", "target_ref": resolved_target or "-", "provider": resolved_provider or "-", "valid_scene": bool(scene_name in scenes), "valid_target": valid_target, }) return { "default_scene": default_scene, "providers": catalog.get("providers", []) or [], "dify_apps": catalog.get("dify_apps", []) or [], "backends": catalog.get("backends", []) or [], "scenes": catalog.get("scenes", []) or [], "plugin_usages": plugin_usages, "topology_rows": topology_rows, } @system_bp.route('/api_docs') @login_required def api_docs(): src = request.args.get('src') if not src: try: server = current_app.dashboard_server cfg = getattr(server.robot, "ipad_config", {}) or {} src = cfg.get("server_url", "http://127.0.0.1:8059/") except Exception: src = "http://127.0.0.1:8059/" return render_template('api_docs.html', src_url=src) @system_bp.route('/system_status') @login_required def system_status(): src = request.args.get('src') if not src: try: server = current_app.dashboard_server glances = getattr(server.robot, "config").glances if hasattr(server.robot, "config") else {} host = glances.get("host", "127.0.0.1") port = glances.get("port", 61208) src = f"http://{host}:{port}/" except Exception: src = "http://127.0.0.1:61208/" return render_template('system_status.html', src_url=src) @system_bp.route('/system_llm') @login_required def system_llm(): return render_template('system_llm.html') # 页面路由 @system_bp.route('/wx_logs') @login_required def wx_logs(): return render_template('wx_logs.html') # API路由 @system_bp.route('/api/system_info') @login_required def api_system_info(): try: # 获取系统信息 system_info = { "os": platform.system(), "os_version": platform.version(), "python_version": platform.python_version(), "cpu_usage": psutil.cpu_percent(), "memory_usage": psutil.virtual_memory().percent, "disk_usage": psutil.disk_usage('/').percent, "uptime": time.time() - APP_START_TIME, # 使用应用启动时间计算运行时长 "timestamp": datetime.now().strftime("%Y-%m-%d %H:%M:%S"), "open_files": len(psutil.Process(os.getpid()).open_files()) } return jsonify({"success": True, "data": system_info}) except Exception as e: logger.error(f"获取系统信息失败: {e}") return jsonify({"success": False, "error": str(e)}), 500 @system_bp.route('/api/system_health_summary') @login_required def api_system_health_summary(): """聚合首页可观测性所需的关键健康信号。""" try: server = current_app.dashboard_server robot = getattr(server, "robot", None) plugin_manager = getattr(server, "plugin_manager", None) plugin_map = getattr(plugin_manager, "plugins", {}) or {} # 统计插件运行状态，便于首页快速判断“加载了多少、真正跑起来多少、是否有异常插件”。 plugin_status_counter = { "total": len(plugin_map), "running": 0, "loaded": 0, "stopped": 0, "error": 0, "unloaded": 0, "unknown": 0, } for plugin in plugin_map.values(): status = getattr(plugin, "status", None) if status == PluginStatus.RUNNING: plugin_status_counter["running"] += 1 elif status == PluginStatus.LOADED: plugin_status_counter["loaded"] += 1 elif status == PluginStatus.STOPPED: plugin_status_counter["stopped"] += 1 elif status == PluginStatus.ERROR: plugin_status_counter["error"] += 1 elif status == PluginStatus.UNLOADED: plugin_status_counter["unloaded"] += 1 else: plugin_status_counter["unknown"] += 1 # 错误数量直接复用现有统计库，避免为了首页卡片再单独写一套 SQL。 _, recent_error_count = server.stats_db.get_error_logs(days=1, page=1, limit=1) # 基础设施健康： # 1. MySQL 用最轻量的 SELECT 1 做可用性探测； # 2. Redis 用 PING 验证连接池当前是否可拿到可用连接； # 3. 即使探测失败也只反馈到看板，不影响主接口整体返回。 mysql_status = "healthy" mysql_summary = "连接正常" try: mysql_conn = server.db_manager.get_mysql_connection() try: with mysql_conn.cursor() as cursor: cursor.execute("SELECT 1") cursor.fetchone() finally: mysql_conn.close() except Exception as mysql_error: mysql_status = "danger" mysql_summary = f"MySQL 探测失败: {mysql_error}" redis_status = "healthy" redis_summary = "连接正常" try: redis_conn = server.db_manager.get_redis_connection() redis_conn.ping() except Exception as redis_error: redis_status = "danger" redis_summary = f"Redis 探测失败: {redis_error}" # md2img 健康快照已经有现成实现，这里只做聚合，不主动预热运行时。 md2img_snapshot = get_md2img_health_snapshot(ensure_runtime=False) or {} browser_ready = bool( md2img_snapshot.get("browser_ready") or md2img_snapshot.get("playwright_ready") or md2img_snapshot.get("ready") ) runtime_ready = bool( md2img_snapshot.get("runtime_ready") or md2img_snapshot.get("runtime_initialized") or md2img_snapshot.get("initialized") ) md2img_healthy = runtime_ready and browser_ready # 首页只需要“够判断”的轻量结论，因此统一产出 status + summary 文本，前端无需重复拼装业务规则。 robot_running = bool(getattr(robot, "ipad_running", False)) robot_nickname = str(getattr(robot, "nickname", "") or "").strip() robot_wxid = str(getattr(robot, "wxid", "") or "").strip() robot_summary = "已连接并正在处理消息" if robot_running else "未连接或主循环未运行" if robot_nickname or robot_wxid: robot_summary = f"{robot_summary} · {robot_nickname or robot_wxid}" if plugin_status_counter["error"] > 0: plugin_status = "warning" plugin_summary = f"异常 {plugin_status_counter['error']} 个，运行中 {plugin_status_counter['running']} / {plugin_status_counter['total']}" elif plugin_status_counter["running"] == 0 and plugin_status_counter["total"] > 0: plugin_status = "warning" plugin_summary = f"暂无运行中插件，共加载 {plugin_status_counter['total']} 个" else: plugin_status = "healthy" plugin_summary = f"运行中 {plugin_status_counter['running']} / {plugin_status_counter['total']}" if recent_error_count > 0: error_status = "warning" error_summary = f"近 24 小时记录到 {recent_error_count} 条异常" else: error_status = "healthy" error_summary = "近 24 小时未记录到异常" if md2img_healthy: md2img_status = "healthy" md2img_summary = "运行时与浏览器均已就绪" elif runtime_ready or browser_ready: md2img_status = "warning" md2img_summary = "运行时部分可用，建议检查预热状态" else: md2img_status = "danger" md2img_summary = "运行时未就绪，相关转图能力可能不可用" # AI 运行态： # 1. 统一从 UnifiedLLMClient 最近调用窗口读取，避免各插件单独维护监控数据； # 2. 若当前窗口还没有调用记录，就明确返回“暂无调用”，避免误判成异常。 ai_runtime = UnifiedLLMClient.get_runtime_snapshot() ai_total_calls = int(ai_runtime.get("total_calls") or 0) ai_failed_calls = int(ai_runtime.get("failed_calls") or 0) if ai_total_calls <= 0: ai_status = "warning" ai_summary = "最近窗口内暂无统一 LLM 调用记录" elif ai_failed_calls > 0: ai_status = "warning" ai_summary = ( f"最近 {ai_total_calls} 次调用中失败 {ai_failed_calls} 次，" f"平均耗时 {ai_runtime.get('avg_latency_ms', 0)}ms" ) else: ai_status = "healthy" ai_summary = ( f"最近 {ai_total_calls} 次调用全部成功，" f"平均耗时 {ai_runtime.get('avg_latency_ms', 0)}ms" ) return jsonify({ "success": True, "data": { "timestamp": datetime.now().strftime("%Y-%m-%d %H:%M:%S"), "robot": { "status": "healthy" if robot_running else "danger", "running": robot_running, "nickname": robot_nickname, "wxid": robot_wxid, "summary": robot_summary, }, "plugins": { "status": plugin_status, "summary": plugin_summary, **plugin_status_counter, }, "errors": { "status": error_status, "recent_24h_count": recent_error_count, "summary": error_summary, }, "infrastructure": { "status": "healthy" if mysql_status == "healthy" and redis_status == "healthy" else "danger", "summary": ( "MySQL / Redis 均正常" if mysql_status == "healthy" and redis_status == "healthy" else "存在基础设施连接异常" ), "mysql": { "status": mysql_status, "summary": mysql_summary, }, "redis": { "status": redis_status, "summary": redis_summary, }, }, "ai_runtime": { "status": ai_status, "summary": ai_summary, **ai_runtime, }, "md2img": { "status": md2img_status, "healthy": md2img_healthy, "runtime_ready": runtime_ready, "browser_ready": browser_ready, "summary": md2img_summary, "detail": md2img_snapshot, }, } }) except Exception as e: logger.error(f"获取系统健康摘要失败: {e}") return jsonify({"success": False, "error": str(e)}), 500 @system_bp.route('/api/wx_logs') @login_required def api_wx_logs(): try: log_type = request.args.get('type', 'info') # 默认显示info日志 lines = request.args.get('lines', 100, type=int) # 默认显示最后100行 # 修正日志文件路径计算，获取项目根目录 project_root = os.path.abspath(os.path.join(os.path.dirname(__file__), '..', '..', '..','logs')) if log_type == 'error': log_file = os.path.join(project_root, 'wx_error.log') elif log_type == 'debug': log_file = os.path.join(project_root, 'wx_debug.log') else: log_file = os.path.join(project_root, 'wx_info.log') log_content = [] if os.path.exists(log_file): try: chunk_size = 8192 with open(log_file, 'rb') as f: f.seek(0, os.SEEK_END) size = f.tell() buffer = b"" pos = size while pos > 0 and buffer.count(b'\n') <= lines: read_size = chunk_size if pos >= chunk_size else pos pos -= read_size f.seek(pos) buffer = f.read(read_size) + buffer log_content = [b.decode('utf-8', errors='ignore') for b in buffer.splitlines()[-lines:]] except Exception as e: logger.error(f"高效读取日志失败，回退到常规方式: {e}") with open(log_file, 'r', encoding='utf-8', errors='ignore') as f: log_content = list(deque(f, lines)) else: logger.warning(f"日志文件不存在: {log_file}") # 尝试列出项目根目录下的所有日志文件，帮助调试 try: all_files = [f for f in os.listdir(project_root) if f.endswith('.log')] logger.info(f"项目根目录下的日志文件: {all_files}") except Exception as e: logger.error(f"列出目录文件失败: {e}") payload = { "success": True, "data": { "log_type": log_type, "log_file": log_file, "content": log_content, "lines": len(log_content) } } accept = request.headers.get('Accept-Encoding', '') if 'gzip' in accept.lower(): body = json.dumps(payload, ensure_ascii=False).encode('utf-8') gz = gzip.compress(body, compresslevel=6) resp = Response(gz, mimetype='application/json') resp.headers['Content-Encoding'] = 'gzip' return resp return jsonify(payload) except Exception as e: logger.error(f"获取微信日志失败: {e}") return jsonify({"success": False, "error": str(e)}), 500 # 在现有路由下添加 @system_bp.route('/api/current_user_info', methods=['GET']) @login_required def get_current_user_info(): """获取当前登录的微信用户信息""" dashboard_server = current_app.dashboard_server result = dashboard_server.get_current_user_info() return jsonify(result) @system_bp.route('/api/system/config/raw', methods=['GET']) @login_required def get_system_config_raw(): try: config_path = _system_config_path() with open(config_path, 'r', encoding='utf-8') as f: config_text = f.read() # 展示运行时目录中的目标对象（backend+dify_app），便于调试 scene 绑定。 catalog = _load_llm_catalog_runtime() backend_names = [str(item.get("name") or "").strip() for item in (catalog.get("backends", []) or [])] app_names = [f"dify_app::{str(item.get('name') or '').strip()}" for item in (catalog.get("dify_apps", []) or [])] return jsonify({ "success": True, "data": config_text, "path": config_path, "llm_backends": sorted([name for name in backend_names + app_names if name]), }) except Exception as e: logger.error(f"读取系统配置失败: {e}") return jsonify({"success": False, "message": str(e)}), 500 @system_bp.route('/api/system/config/update', methods=['POST']) @login_required def update_system_config(): try: server = current_app.dashboard_server data = request.get_json() or {} config_text = data.get("config_text") if config_text is None: return jsonify({"success": False, "message": "缺少配置内容"}), 400 yaml.safe_load(config_text) config_path = _system_config_path() with open(config_path, 'w', encoding='utf-8') as f: f.write(config_text) if getattr(server, "robot", None) and getattr(server.robot, "config", None): server.robot.config.reload() # 保存 YAML 后立刻把运行时依赖对象同步一遍，避免必须重启进程才能读到新值。 server.robot.apply_runtime_config(reload_catalog=True) else: # 即便当前没有可用 robot 实例，也尽量把 LLM 路由缓存清掉，避免后续请求短时间内读旧值。 LLMRegistry.invalidate_cache() return jsonify({"success": True, "message": "全局配置已保存并应用到运行时"}) except Exception as e: logger.error(f"保存系统配置失败: {e}") return jsonify({"success": False, "message": str(e)}), 500 @system_bp.route('/api/system/llm_config', methods=['GET']) @login_required def get_system_llm_config(): try: catalog = _load_llm_catalog_runtime() providers = sorted((catalog.get("providers", []) or []), key=lambda item: str(item.get("name") or "")) dify_apps = sorted((catalog.get("dify_apps", []) or []), key=lambda item: str(item.get("name") or "")) backends = sorted((catalog.get("backends", []) or []), key=lambda item: str(item.get("name") or "")) scenes = sorted((catalog.get("scenes", []) or []), key=lambda item: str(item.get("name") or "")) topology = _build_llm_topology() return jsonify({ "success": True, "data": { "default_scene": catalog.get("default_scene", ""), "providers": providers, "dify_apps": dify_apps, "backends": backends, "scenes": scenes, "topology_rows": topology.get("topology_rows", []), "plugin_usages": topology.get("plugin_usages", []), # 新目录模型主存储在 MySQL。 "config_path": ( "mysql:t_llm_provider_templates + t_llm_dify_apps + " "t_llm_backends + t_llm_scenes (fallback yaml)" ), } }) except Exception as e: logger.error(f"读取全局 LLM 配置失败: {e}") return jsonify({"success": False, "message": str(e)}), 500 @system_bp.route('/api/system/llm_config', methods=['POST']) @login_required def update_system_llm_config(): try: server = current_app.dashboard_server data = request.get_json() or {} default_scene = str(data.get("default_scene") or "").strip() provider_list = data.get("providers", []) or [] dify_app_list = data.get("dify_apps", []) or [] backend_list = data.get("backends", []) or [] scene_list = data.get("scenes", []) or [] if not isinstance(provider_list, list): return jsonify({"success": False, "message": "providers 格式不正确"}), 400 if not isinstance(dify_app_list, list): return jsonify({"success": False, "message": "dify_apps 格式不正确"}), 400 if not isinstance(backend_list, list): return jsonify({"success": False, "message": "backends 格式不正确"}), 400 if not isinstance(scene_list, list): return jsonify({"success": False, "message": "scenes 格式不正确"}), 400 # 目录级校验：先收集名字集合，便于 scene target 引用校验。 provider_names = { str((item or {}).get("name") or "").strip() for item in provider_list if isinstance(item, dict) and str((item or {}).get("name") or "").strip() } dify_app_names = { str((item or {}).get("name") or "").strip() for item in dify_app_list if isinstance(item, dict) and str((item or {}).get("name") or "").strip() } backend_names = { str((item or {}).get("name") or "").strip() for item in backend_list if isinstance(item, dict) and str((item or {}).get("name") or "").strip() } for app in dify_app_list: if not isinstance(app, dict): continue app_name = str(app.get("name") or "").strip() if not app_name: continue provider_template = str(app.get("provider_template") or "").strip() if not provider_template: return jsonify({"success": False, "message": f"Dify应用 {app_name} 未绑定 Provider 模板"}), 400 if provider_template not in provider_names: return jsonify({"success": False, "message": f"Dify应用 {app_name} 绑定的 Provider 不存在"}), 400 app_key = str(app.get("app_key") or "").strip() if not app_key: return jsonify({"success": False, "message": f"Dify应用 {app_name} 缺少 app_key"}), 400 scene_names = set() for scene in scene_list: if not isinstance(scene, dict): continue scene_name = str(scene.get("name") or "").strip() target_type = str(scene.get("target_type") or "").strip().lower() target_ref = str(scene.get("target_ref") or "").strip() if not scene_name: continue if scene_name in scene_names: return jsonify({"success": False, "message": f"场景名重复: {scene_name}"}), 400 scene_names.add(scene_name) if target_type not in {"dify_app", "backend"}: return jsonify({"success": False, "message": f"场景 {scene_name} target_type 非法"}), 400 if not target_ref: return jsonify({"success": False, "message": f"场景 {scene_name} 未绑定目标"}), 400 if target_type == "dify_app" and target_ref not in dify_app_names: return jsonify({"success": False, "message": f"场景 {scene_name} 绑定的 dify_app 不存在"}), 400 if target_type == "backend" and target_ref not in backend_names: return jsonify({"success": False, "message": f"场景 {scene_name} 绑定的 backend 不存在"}), 400 if default_scene and default_scene not in scene_names: return jsonify({"success": False, "message": "默认场景不存在"}), 400 catalog = { "default_scene": default_scene, "providers": provider_list, "dify_apps": dify_app_list, "backends": backend_list, "scenes": scene_list, } _save_llm_catalog_runtime(catalog) if getattr(server, "robot", None) and getattr(server.robot, "config", None): server.robot.config.reload() # LLM 目录保存到 MySQL 后，需要主动失效运行时缓存，保证插件下一次调用直接走新目录。 server.robot.apply_runtime_config(reload_catalog=True) else: LLMRegistry.invalidate_cache() return jsonify({"success": True, "message": "全局 LLM 配置已保存并应用到运行时"}) except Exception as e: logger.error(f"保存全局 LLM 配置失败: {e}") return jsonify({"success": False, "message": str(e)}), 500 @system_bp.route('/api/system/md2img_health', methods=['GET']) @login_required def get_md2img_health(): """查询 Markdown 转图运行时健康状态。""" try: # 默认只读取状态，不主动拉起 runtime。 # 当后台希望“刷新并顺便拉起”时，可传 ensure_runtime=true。 ensure_runtime = str(request.args.get('ensure_runtime', 'false')).strip().lower() in {'1', 'true', 'yes', 'on'} data = get_md2img_health_snapshot(ensure_runtime=ensure_runtime) return jsonify({"success": True, "data": data}) except Exception as e: logger.error(f"获取 md2img 健康状态失败: {e}") return jsonify({"success": False, "message": str(e)}), 500 @system_bp.route('/api/system/md2img_warmup', methods=['POST']) @login_required def trigger_md2img_warmup(): """手动触发 Markdown 转图浏览器预热。""" try: payload = request.get_json(silent=True) or {} timeout_seconds = int(payload.get('timeout_seconds', 45) or 45) timeout_seconds = max(10, min(timeout_seconds, 180)) ok = warmup_md2img_browser_sync(timeout_seconds=timeout_seconds) data = get_md2img_health_snapshot(ensure_runtime=False) if ok: return jsonify({ "success": True, "message": f"预热完成（timeout={timeout_seconds}s）", "data": data, }) return jsonify({ "success": False, "message": f"预热失败（timeout={timeout_seconds}s），请查看运行日志", "data": data, }), 500 except Exception as e: logger.error(f"触发 md2img 预热失败: {e}") return jsonify({"success": False, "message": str(e)}), 500 @system_bp.route('/api/restart_service', methods=['POST']) @login_required def restart_service(): """调用项目根目录下的 restart.sh 重启服务""" try: project_root = os.path.abspath(os.path.join(os.path.dirname(__file__), '..', '..', '..')) script_path = os.path.join(project_root, 'restart.sh') if not os.path.exists(script_path): return jsonify({"success": False, "message": f"未找到脚本: {script_path}"}), 404 subprocess.Popen( ['bash', script_path], cwd=project_root, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL, start_new_session=True ) logger.warning(f"后台触发服务重启脚本: {script_path}") return jsonify({ "success": True, "message": "已触发重启脚本，服务将在短时间内重启" }) except Exception as e: logger.error(f"触发服务重启失败: {e}") return jsonify({"success": False, "message": str(e)}), 500