AstrBot 3.5.6__py3-none-any.whl → 4.7.0__py3-none-any.whl

astrbot/dashboard/routes/update.py

@@ -1,12 +1,17 @@
 import traceback
-from .route import Route, Response, RouteContext
+
 from quart import request
+
+from astrbot.core import DEMO_MODE, logger, pip_installer
+from astrbot.core.config.default import VERSION
 from astrbot.core.core_lifecycle import AstrBotCoreLifecycle
+from astrbot.core.db.migration.helper import check_migration_needed_v4, do_migration_v4
 from astrbot.core.updator import AstrBotUpdator
-from astrbot.core import logger, pip_installer
 from astrbot.core.utils.io import download_dashboard, get_dashboard_version
-from astrbot.core.config.default import VERSION
-from astrbot.core import DEMO_MODE
+
+from .route import Response, Route, RouteContext
+
+CLEAR_SITE_DATA_HEADERS = {"Clear-Site-Data": '"cache"'}
 
 
 class UpdateRoute(Route):
@@ -23,11 +28,29 @@ class UpdateRoute(Route):
             "/update/do": ("POST", self.update_project),
             "/update/dashboard": ("POST", self.update_dashboard),
             "/update/pip-install": ("POST", self.install_pip_package),
+            "/update/migration": ("POST", self.do_migration),
         }
         self.astrbot_updator = astrbot_updator
         self.core_lifecycle = core_lifecycle
         self.register_routes()
 
+    async def do_migration(self):
+        need_migration = await check_migration_needed_v4(self.core_lifecycle.db)
+        if not need_migration:
+            return Response().ok(None, "不需要进行迁移。").__dict__
+        try:
+            data = await request.json
+            pim = data.get("platform_id_map", {})
+            await do_migration_v4(
+                self.core_lifecycle.db,
+                pim,
+                self.core_lifecycle.astrbot_config,
+            )
+            return Response().ok(None, "迁移成功。").__dict__
+        except Exception as e:
+            logger.error(f"迁移失败: {traceback.format_exc()}")
+            return Response().error(f"迁移失败: {e!s}").__dict__
+
     async def check_update(self):
         type_ = request.args.get("type", None)
 
@@ -39,20 +62,19 @@ class UpdateRoute(Route):
                     .ok({"has_new_version": dv != f"v{VERSION}", "current_version": dv})
                     .__dict__
                 )
-            else:
-                ret = await self.astrbot_updator.check_update(None, None)
-                return Response(
-                    status="success",
-                    message=str(ret) if ret is not None else "已经是最新版本了。",
-                    data={
-                        "version": f"v{VERSION}",
-                        "has_new_version": ret is not None,
-                        "dashboard_version": dv,
-                        "dashboard_has_new_version": dv != f"v{VERSION}",
-                    },
-                ).__dict__
+            ret = await self.astrbot_updator.check_update(None, None, False)
+            return Response(
+                status="success",
+                message=str(ret) if ret is not None else "已经是最新版本了。",
+                data={
+                    "version": f"v{VERSION}",
+                    "has_new_version": ret is not None,
+                    "dashboard_version": dv,
+                    "dashboard_has_new_version": bool(dv and dv != f"v{VERSION}"),
+                },
+            ).__dict__
         except Exception as e:
-            logger.warning(f"检查更新失败: {str(e)} (不影响除项目更新外的正常使用)")
+            logger.warning(f"检查更新失败: {e!s} (不影响除项目更新外的正常使用)")
             return Response().error(e.__str__()).__dict__
 
     async def get_releases(self):
@@ -79,35 +101,37 @@ class UpdateRoute(Route):
 
         try:
             await self.astrbot_updator.update(
-                latest=latest, version=version, proxy=proxy
+                latest=latest,
+                version=version,
+                proxy=proxy,
             )
 
-            if latest:
-                try:
-                    await download_dashboard()
-                except Exception as e:
-                    logger.error(f"下载管理面板文件失败: {e}。")
+            try:
+                await download_dashboard(latest=latest, version=version, proxy=proxy)
+            except Exception as e:
+                logger.error(f"下载管理面板文件失败: {e}。")
 
             # pip 更新依赖
             logger.info("更新依赖中...")
             try:
-                pip_installer.install(requirements_path="requirements.txt")
+                await pip_installer.install(requirements_path="requirements.txt")
             except Exception as e:
                 logger.error(f"更新依赖失败: {e}")
 
             if reboot:
                 await self.core_lifecycle.restart()
-                return (
+                ret = (
                     Response()
                     .ok(None, "更新成功，AstrBot 将在 2 秒内全量重启以应用新的代码。")
                     .__dict__
                 )
-            else:
-                return (
-                    Response()
-                    .ok(None, "更新成功，AstrBot 将在下次启动时应用新的代码。")
-                    .__dict__
-                )
+                return ret, 200, CLEAR_SITE_DATA_HEADERS
+            ret = (
+                Response()
+                .ok(None, "更新成功，AstrBot 将在下次启动时应用新的代码。")
+                .__dict__
+            )
+            return ret, 200, CLEAR_SITE_DATA_HEADERS
         except Exception as e:
             logger.error(f"/api/update_project: {traceback.format_exc()}")
             return Response().error(e.__str__()).__dict__
@@ -115,13 +139,12 @@ class UpdateRoute(Route):
     async def update_dashboard(self):
         try:
             try:
-                await download_dashboard()
+                await download_dashboard(version=f"v{VERSION}", latest=False)
             except Exception as e:
                 logger.error(f"下载管理面板文件失败: {e}。")
                 return Response().error(f"下载管理面板文件失败: {e}").__dict__
-            return (
-                Response().ok(None, "更新成功。刷新页面即可应用新版本面板。").__dict__
-            )
+            ret = Response().ok(None, "更新成功。刷新页面即可应用新版本面板。").__dict__
+            return ret, 200, CLEAR_SITE_DATA_HEADERS
         except Exception as e:
             logger.error(f"/api/update_dashboard: {traceback.format_exc()}")
             return Response().error(e.__str__()).__dict__
@@ -140,7 +163,7 @@ class UpdateRoute(Route):
         if not package:
             return Response().error("缺少参数 package 或不合法。").__dict__
         try:
-            pip_installer.install(package, mirror=mirror)
+            await pip_installer.install(package, mirror=mirror)
             return Response().ok(None, "安装成功。").__dict__
         except Exception as e:
             logger.error(f"/api/update_pip: {traceback.format_exc()}")

astrbot/dashboard/server.py

@@ -1,22 +1,26 @@
-import logging
-import jwt
 import asyncio
+import logging
 import os
 import socket
+
+import jwt
 import psutil
-from astrbot.core.config.default import VERSION
-from quart import Quart, request, jsonify, g
+from quart import Quart, g, jsonify, request
 from quart.logging import default_handler
+
+from astrbot.core import logger
+from astrbot.core.config.default import VERSION
 from astrbot.core.core_lifecycle import AstrBotCoreLifecycle
-from .routes import *
-from .routes.route import RouteContext, Response
-from astrbot.core import logger, WEBUI_SK
 from astrbot.core.db import BaseDatabase
+from astrbot.core.utils.astrbot_path import get_astrbot_data_path
 from astrbot.core.utils.io import get_local_ip_addresses
 
-DATAPATH = os.path.abspath(
-    os.path.join(os.path.dirname(os.path.abspath(__file__)), "../../data")
-)
+from .routes import *
+from .routes.route import Response, RouteContext
+from .routes.session_management import SessionManagementRoute
+from .routes.t2i import T2iRoute
+
+APP: Quart = None
 
 
 class AstrBotDashboard:
@@ -25,11 +29,21 @@ class AstrBotDashboard:
         core_lifecycle: AstrBotCoreLifecycle,
         db: BaseDatabase,
         shutdown_event: asyncio.Event,
+        webui_dir: str | None = None,
     ) -> None:
         self.core_lifecycle = core_lifecycle
         self.config = core_lifecycle.astrbot_config
-        self.data_path = os.path.abspath(os.path.join(DATAPATH, "dist"))
+
+        # 参数指定webui目录
+        if webui_dir and os.path.exists(webui_dir):
+            self.data_path = os.path.abspath(webui_dir)
+        else:
+            self.data_path = os.path.abspath(
+                os.path.join(get_astrbot_data_path(), "dist"),
+            )
+
         self.app = Quart("dashboard", static_folder=self.data_path, static_url_path="/")
+        APP = self.app  # noqa
         self.app.config["MAX_CONTENT_LENGTH"] = (
             128 * 1024 * 1024
         )  # 将 Flask 允许的最大上传文件体大小设置为 128 MB
@@ -39,11 +53,15 @@ class AstrBotDashboard:
         logging.getLogger(self.app.name).removeHandler(default_handler)
         self.context = RouteContext(self.config, self.app)
         self.ur = UpdateRoute(
-            self.context, core_lifecycle.astrbot_updator, core_lifecycle
+            self.context,
+            core_lifecycle.astrbot_updator,
+            core_lifecycle,
         )
         self.sr = StatRoute(self.context, db, core_lifecycle)
         self.pr = PluginRoute(
-            self.context, core_lifecycle, core_lifecycle.plugin_manager
+            self.context,
+            core_lifecycle,
+            core_lifecycle.plugin_manager,
         )
         self.cr = ConfigRoute(self.context, core_lifecycle)
         self.lr = LogRoute(self.context, core_lifecycle.log_broker)
@@ -52,26 +70,50 @@ class AstrBotDashboard:
         self.chat_route = ChatRoute(self.context, db, core_lifecycle)
         self.tools_root = ToolsRoute(self.context, core_lifecycle)
         self.conversation_route = ConversationRoute(self.context, db, core_lifecycle)
+        self.file_route = FileRoute(self.context)
+        self.session_management_route = SessionManagementRoute(
+            self.context,
+            db,
+            core_lifecycle,
+        )
+        self.persona_route = PersonaRoute(self.context, db, core_lifecycle)
+        self.t2i_route = T2iRoute(self.context, core_lifecycle)
+        self.kb_route = KnowledgeBaseRoute(self.context, core_lifecycle)
+
+        self.app.add_url_rule(
+            "/api/plug/<path:subpath>",
+            view_func=self.srv_plug_route,
+            methods=["GET", "POST"],
+        )
 
         self.shutdown_event = shutdown_event
 
+        self._init_jwt_secret()
+
+    async def srv_plug_route(self, subpath, *args, **kwargs):
+        """插件路由"""
+        registered_web_apis = self.core_lifecycle.star_context.registered_web_apis
+        for api in registered_web_apis:
+            route, view_handler, methods, _ = api
+            if route == f"/{subpath}" and request.method in methods:
+                return await view_handler(*args, **kwargs)
+        return jsonify(Response().error("未找到该路由").__dict__)
+
     async def auth_middleware(self):
         if not request.path.startswith("/api"):
-            return
-        if request.path == "/api/auth/login":
-            return
-        if request.path == "/api/chat/get_file":
-            return
-        # claim jwt
+            return None
+        allowed_endpoints = ["/api/auth/login", "/api/file"]
+        if any(request.path.startswith(prefix) for prefix in allowed_endpoints):
+            return None
+        # 声明 JWT
         token = request.headers.get("Authorization")
         if not token:
             r = jsonify(Response().error("未授权").__dict__)
             r.status_code = 401
             return r
-        if token.startswith("Bearer "):
-            token = token[7:]
+        token = token.removeprefix("Bearer ")
         try:
-            payload = jwt.decode(token, WEBUI_SK, algorithms=["HS256"])
+            payload = jwt.decode(token, self._jwt_secret, algorithms=["HS256"])
             g.username = payload["username"]
         except jwt.ExpiredSignatureError:
             r = jsonify(Response().error("Token 过期").__dict__)
@@ -83,9 +125,7 @@ class AstrBotDashboard:
             return r
 
     def check_port_in_use(self, port: int) -> bool:
-        """
-        跨平台检测端口是否被占用
-        """
+        """跨平台检测端口是否被占用"""
         try:
             # 创建 IPv4 TCP Socket
             sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
@@ -97,7 +137,7 @@ class AstrBotDashboard:
             # result 为 0 表示端口被占用
             return result == 0
         except Exception as e:
-            logger.warning(f"检查端口 {port} 时发生错误: {str(e)}")
+            logger.warning(f"检查端口 {port} 时发生错误: {e!s}")
             # 如果出现异常，保守起见认为端口可能被占用
             return True
 
@@ -118,21 +158,38 @@ class AstrBotDashboard:
                         ]
                         return "\n           ".join(proc_info)
                     except (psutil.NoSuchProcess, psutil.AccessDenied) as e:
-                        return f"无法获取进程详细信息(可能需要管理员权限): {str(e)}"
+                        return f"无法获取进程详细信息(可能需要管理员权限): {e!s}"
             return "未找到占用进程"
         except Exception as e:
-            return f"获取进程信息失败: {str(e)}"
+            return f"获取进程信息失败: {e!s}"
+
+    def _init_jwt_secret(self):
+        if not self.config.get("dashboard", {}).get("jwt_secret", None):
+            # 如果没有设置 JWT 密钥，则生成一个新的密钥
+            jwt_secret = os.urandom(32).hex()
+            self.config["dashboard"]["jwt_secret"] = jwt_secret
+            self.config.save_config()
+            logger.info("Initialized random JWT secret for dashboard.")
+        self._jwt_secret = self.config["dashboard"]["jwt_secret"]
 
     def run(self):
         ip_addr = []
-        port = self.core_lifecycle.astrbot_config["dashboard"].get("port", 6185)
+        if p := os.environ.get("DASHBOARD_PORT"):
+            port = p
+        else:
+            port = self.core_lifecycle.astrbot_config["dashboard"].get("port", 6185)
         host = self.core_lifecycle.astrbot_config["dashboard"].get("host", "0.0.0.0")
+        enable = self.core_lifecycle.astrbot_config["dashboard"].get("enable", True)
+
+        if not enable:
+            logger.info("WebUI 已被禁用")
+            return None
 
         logger.info(f"正在启动 WebUI, 监听地址: http://{host}:{port}")
 
         if host == "0.0.0.0":
             logger.info(
-                "提示: WebUI 将监听所有网络接口，请注意安全。（可在 data/cmd_config.json 中配置 dashboard.host 以修改 host）"
+                "提示: WebUI 将监听所有网络接口，请注意安全。（可在 data/cmd_config.json 中配置 dashboard.host 以修改 host）",
             )
 
         if host not in ["localhost", "127.0.0.1"]:
@@ -151,16 +208,17 @@ class AstrBotDashboard:
                 f"请确保：\n"
                 f"1. 没有其他 AstrBot 实例正在运行\n"
                 f"2. 端口 {port} 没有被其他程序占用\n"
-                f"3. 如需使用其他端口，请修改配置文件"
+                f"3. 如需使用其他端口，请修改配置文件",
             )
 
             raise Exception(f"端口 {port} 已被占用")
 
-        display = f"\n ✨✨✨\n  AstrBot v{VERSION} WebUI 已启动，可访问\n\n"
-        display += f"   ➜  本地: http://localhost:{port}\n"
+        parts = [f"\n ✨✨✨\n  AstrBot v{VERSION} WebUI 已启动，可访问\n\n"]
+        parts.append(f"   ➜  本地: http://localhost:{port}\n")
         for ip in ip_addr:
-            display += f"   ➜  网络: http://{ip}:{port}\n"
-        display += "   ➜  默认用户名和密码: astrbot\n ✨✨✨\n"
+            parts.append(f"   ➜  网络: http://{ip}:{port}\n")
+        parts.append("   ➜  默认用户名和密码: astrbot\n ✨✨✨\n")
+        display = "".join(parts)
 
         if not ip_addr:
             display += (
@@ -170,7 +228,9 @@ class AstrBotDashboard:
         logger.info(display)
 
         return self.app.run_task(
-            host=host, port=port, shutdown_trigger=self.shutdown_trigger
+            host=host,
+            port=port,
+            shutdown_trigger=self.shutdown_trigger,
         )
 
     async def shutdown_trigger(self):

astrbot/dashboard/utils.py

@@ -0,0 +1,165 @@
+import base64
+import os
+import traceback
+from io import BytesIO
+
+from astrbot.api import logger
+from astrbot.core.db.vec_db.faiss_impl import FaissVecDB
+from astrbot.core.knowledge_base.kb_helper import KBHelper
+from astrbot.core.knowledge_base.kb_mgr import KnowledgeBaseManager
+
+
+async def generate_tsne_visualization(
+    query: str,
+    kb_names: list[str],
+    kb_manager: KnowledgeBaseManager,
+) -> str | None:
+    """生成 t-SNE 可视化图片
+
+    Args:
+        query: 查询文本
+        kb_names: 知识库名称列表
+        kb_manager: 知识库管理器
+
+    Returns:
+        图片路径或 None
+
+    """
+    try:
+        import faiss
+        import matplotlib
+        import numpy as np
+
+        matplotlib.use("Agg")  # 使用非交互式后端
+        import matplotlib.pyplot as plt
+        from sklearn.manifold import TSNE
+    except ImportError as e:
+        raise Exception(
+            "缺少必要的库以生成 t-SNE 可视化。请安装 matplotlib 和 scikit-learn: {e}",
+        ) from e
+
+    try:
+        # 获取第一个知识库的向量数据
+        kb_helper: KBHelper | None = None
+        for kb_name in kb_names:
+            kb_helper = await kb_manager.get_kb_by_name(kb_name)
+            if kb_helper:
+                break
+
+        if not kb_helper:
+            logger.warning("未找到知识库")
+            return None
+
+        kb = kb_helper.kb
+        index_path = f"data/knowledge_base/{kb.kb_id}/index.faiss"
+
+        # 读取 FAISS 索引
+        if not os.path.exists(index_path):
+            logger.warning(f"FAISS 索引不存在: {index_path}")
+            return None
+
+        index = faiss.read_index(index_path)
+
+        if index.ntotal == 0:
+            logger.warning("索引为空")
+            return None
+
+        # 提取所有向量
+        logger.info(f"提取 {index.ntotal} 个向量用于可视化...")
+        if isinstance(index, faiss.IndexIDMap):
+            base_index = faiss.downcast_index(index.index)
+            if hasattr(base_index, "reconstruct_n"):
+                vectors = base_index.reconstruct_n(0, index.ntotal)
+            else:
+                vectors = np.zeros((index.ntotal, index.d), dtype=np.float32)
+                for i in range(index.ntotal):
+                    base_index.reconstruct(i, vectors[i])
+        elif hasattr(index, "reconstruct_n"):
+            vectors = index.reconstruct_n(0, index.ntotal)
+        else:
+            vectors = np.zeros((index.ntotal, index.d), dtype=np.float32)
+            for i in range(index.ntotal):
+                index.reconstruct(i, vectors[i])
+
+        # 获取查询向量
+        vec_db: FaissVecDB = kb_helper.vec_db  # type: ignore
+        embedding_provider = vec_db.embedding_provider
+        query_embedding = await embedding_provider.get_embedding(query)
+        query_vector = np.array([query_embedding], dtype=np.float32)
+
+        # 合并所有向量和查询向量
+        all_vectors = np.vstack([vectors, query_vector])
+
+        # t-SNE 降维
+        logger.info("开始 t-SNE 降维...")
+        perplexity = min(30, all_vectors.shape[0] - 1)
+        tsne = TSNE(n_components=2, random_state=42, perplexity=perplexity)
+        vectors_2d = tsne.fit_transform(all_vectors)
+
+        # 分离知识库向量和查询向量
+        kb_vectors_2d = vectors_2d[:-1]
+        query_vector_2d = vectors_2d[-1]
+
+        # 可视化
+        logger.info("生成可视化图表...")
+        plt.figure(figsize=(14, 10))
+
+        # 绘制知识库向量
+        scatter = plt.scatter(
+            kb_vectors_2d[:, 0],
+            kb_vectors_2d[:, 1],
+            alpha=0.5,
+            s=40,
+            c=range(len(kb_vectors_2d)),
+            cmap="viridis",
+            label="Knowledge Base Vectors",
+        )
+
+        # 绘制查询向量（红色 X）
+        plt.scatter(
+            query_vector_2d[0],
+            query_vector_2d[1],
+            c="red",
+            s=300,
+            marker="X",
+            edgecolors="black",
+            linewidths=2,
+            label="Query",
+            zorder=5,
+        )
+
+        # 添加查询文本标注
+        plt.annotate(
+            "Query",
+            (query_vector_2d[0], query_vector_2d[1]),
+            xytext=(10, 10),
+            textcoords="offset points",
+            fontsize=10,
+            bbox={"boxstyle": "round,pad=0.5", "fc": "yellow", "alpha": 0.7},
+            arrowprops={"arrowstyle": "->", "connectionstyle": "arc3,rad=0"},
+        )
+
+        plt.colorbar(scatter, label="Vector Index")
+        plt.title(
+            f"t-SNE Visualization: Query in Knowledge Base\n"
+            f"({index.ntotal} vectors, {index.d} dimensions, KB: {kb.kb_name})",
+            fontsize=14,
+            pad=20,
+        )
+        plt.xlabel("t-SNE Dimension 1", fontsize=12)
+        plt.ylabel("t-SNE Dimension 2", fontsize=12)
+        plt.grid(True, alpha=0.3)
+        plt.legend(fontsize=10, loc="upper right")
+
+        # base64 编码图片返回
+        buffer = BytesIO()
+        plt.savefig(buffer, format="png", dpi=150, bbox_inches="tight")
+        plt.close()
+        buffer.seek(0)
+        img_base64 = base64.b64encode(buffer.read()).decode("utf-8")
+        return img_base64
+
+    except Exception as e:
+        logger.error(f"生成 t-SNE 可视化时出错: {e}")
+        logger.error(traceback.format_exc())
+        return None