686 lines
24 KiB
Python
686 lines
24 KiB
Python
# -*- coding: utf-8 -*-
|
||
"""统一 Web 管理系统（/hub）：自动聚合所有注册过的 Web 插件。
|
||
|
||
- 插件在自己 __init__ 里调用 hexi.web_hub.web_plugin_registry.register_web_plugin(...) 注册
|
||
- hub 启动时自动挂载每个插件 API 到 /api/<id>，无需手动配置
|
||
- /hub/api/plugins 由注册中心聚合返回
|
||
"""
|
||
|
||
from __future__ import annotations
|
||
|
||
from pathlib import Path
|
||
import asyncio
|
||
import json
|
||
import logging as _logging
|
||
import os
|
||
import subprocess
|
||
import sys
|
||
import threading
|
||
import time
|
||
|
||
from fastapi import Depends, FastAPI, HTTPException, status
|
||
from fastapi.responses import FileResponse, HTMLResponse, StreamingResponse
|
||
from fastapi.security import OAuth2PasswordRequestForm
|
||
from pydantic import BaseModel
|
||
from starlette.staticfiles import StaticFiles
|
||
|
||
from nonebot import get_driver, logger
|
||
from nonebot.adapters.onebot.v11 import Adapter
|
||
|
||
from .web_auth import (
|
||
authenticate,
|
||
change_password,
|
||
get_current_user,
|
||
get_user_by_token,
|
||
issue_token,
|
||
oauth2_scheme,
|
||
revoke_token,
|
||
sync_admin,
|
||
)
|
||
from .web_plugin_registry import get_web_plugin_builder, list_web_plugins
|
||
|
||
from .dashboard import collect_dashboard
|
||
|
||
# hexi/web_hub 为机器人核心模块（统一 Web 管理台），非 NoneBot 插件
|
||
basic_path = Path(__file__).resolve().parent
|
||
# hexi/web 是统一 Web 管理台前端(hexi/web/dist),不是插件目录下的 web
|
||
WEB_DIST = Path(__file__).resolve().parents[1] / "web" / "dist"
|
||
|
||
def _hub_version() -> str:
|
||
"""管理台版本号：以 hexi/web/package.json 为唯一来源（前端构建也读它）。"""
|
||
try:
|
||
pkg = WEB_DIST.parent / "package.json"
|
||
return str(json.loads(pkg.read_text(encoding="utf-8")).get("version", "0.1.0"))
|
||
except Exception: # noqa: BLE001
|
||
return "0.1.0"
|
||
|
||
# 仓库根目录（bot.py 所在）与 bot 端口
|
||
_REPO_ROOT = Path(__file__).resolve().parents[2]
|
||
_BOT_PORT = 39697
|
||
|
||
# —— 日志清理策略（可用 .env 覆盖）——
|
||
# 单次运行时 _bot_run.log 超过该大小即直接清空（不归档），避免长期运行无限膨胀。
|
||
# 阈值读取优先级：HEXI_LOG_MAX_BYTES(字节) > HEXI_LOG_MAX_MB(MB) > 默认 20MB。
|
||
# 后台清理检查周期（秒）
|
||
_LOG_WATCH_INTERVAL = float(os.environ.get("HEXI_LOG_WATCH_INTERVAL", "60"))
|
||
# 清空互斥锁（防止后台线程与其它路径同时清空）
|
||
_LOG_LOCK = threading.Lock()
|
||
|
||
|
||
def _env_get(name: str, default: str = "") -> str:
|
||
"""读取配置：os.environ > .env 文件 > default。NoneBot 不会把 .env 注入 os.environ，故手动读取。"""
|
||
val = os.getenv(name)
|
||
if val:
|
||
return val
|
||
try:
|
||
env_path = _REPO_ROOT / ".env"
|
||
if env_path.exists():
|
||
for line in env_path.read_text(encoding="utf-8").splitlines():
|
||
line = line.strip()
|
||
if line.startswith(name + "=") or line.startswith(name + " ="):
|
||
return line.split("=", 1)[1].strip().split(" #", maxsplit=1)[0].strip()
|
||
except OSError:
|
||
pass
|
||
return default
|
||
|
||
|
||
def _log_max_bytes() -> int:
|
||
"""日志清理阈值（字节）。优先级：HEXI_LOG_MAX_BYTES > HEXI_LOG_MAX_MB > 默认 20MB。"""
|
||
raw = _env_get("HEXI_LOG_MAX_BYTES")
|
||
if raw:
|
||
try:
|
||
return max(1, int(raw))
|
||
except ValueError:
|
||
pass
|
||
mb = _env_get("HEXI_LOG_MAX_MB")
|
||
if mb:
|
||
try:
|
||
return max(1, int(float(mb)) * 1024 * 1024)
|
||
except ValueError:
|
||
pass
|
||
return 20 * 1024 * 1024
|
||
|
||
|
||
def _spawn_bot() -> None:
|
||
"""以分离进程方式拉起 bot.py：等旧实例释放端口后接管，日志追加到 _bot_run.log。"""
|
||
try:
|
||
log_fp = open(_REPO_ROOT / "_bot_run.log", "ab", buffering=0)
|
||
except OSError:
|
||
log_fp = None
|
||
# 子进程 bootstrap：等端口空闲 -> 直接以 __main__ 运行 bot.py（该进程即 bot，不残留 wrapper）
|
||
bootstrap = (
|
||
"import socket,time,sys,runpy\n"
|
||
"port=%d\n" % _BOT_PORT
|
||
+ "for _ in range(120):\n"
|
||
" s=socket.socket()\n"
|
||
" try:\n"
|
||
" s.bind(('0.0.0.0',port)); s.close(); break\n"
|
||
" except OSError:\n"
|
||
" s.close(); time.sleep(0.5)\n"
|
||
"else:\n"
|
||
" sys.exit(2)\n"
|
||
"runpy.run_path('bot.py', run_name='__main__')\n"
|
||
)
|
||
flags = 0
|
||
if hasattr(subprocess, "CREATE_NEW_PROCESS_GROUP"):
|
||
flags |= subprocess.CREATE_NEW_PROCESS_GROUP
|
||
if hasattr(subprocess, "DETACHED_PROCESS"):
|
||
flags |= subprocess.DETACHED_PROCESS
|
||
env = {**os.environ, "PYTHONIOENCODING": "utf-8", "PYTHONUTF8": "1"}
|
||
subprocess.Popen(
|
||
[sys.executable, "-c", bootstrap],
|
||
cwd=str(_REPO_ROOT),
|
||
stdout=log_fp,
|
||
stderr=subprocess.STDOUT,
|
||
creationflags=flags,
|
||
env=env,
|
||
)
|
||
|
||
|
||
def _purge_legacy_archives() -> None:
|
||
"""删除历史遗留的 bot_run_*.log 归档（策略改为不归档，仅保留当前 _bot_run.log）。"""
|
||
logs_dir = _REPO_ROOT / "hexi" / "logs"
|
||
try:
|
||
for p in logs_dir.glob("bot_run_*.log"):
|
||
try:
|
||
p.unlink()
|
||
except OSError:
|
||
pass
|
||
except OSError as e: # noqa: BLE001
|
||
logger.warning(f"清理历史归档日志失败: {type(e).__name__}: {e}")
|
||
|
||
|
||
def _clear_log() -> None:
|
||
"""把 _bot_run.log 截断清空（不归档）。写端均为 append 模式，截断后下次写入从头续写。"""
|
||
with _LOG_LOCK:
|
||
log = _REPO_ROOT / "_bot_run.log"
|
||
if not log.exists():
|
||
return
|
||
try:
|
||
open(log, "wb").close()
|
||
logger.info("_bot_run.log 超过阈值，已清空（不归档）。")
|
||
except OSError as e: # noqa: BLE001
|
||
logger.warning(f"清空日志失败: {type(e).__name__}: {e}")
|
||
|
||
|
||
def _rotate_log_if_needed() -> None:
|
||
"""当 _bot_run.log 超过阈值时直接清空（不归档），避免长期运行无限膨胀。"""
|
||
try:
|
||
log = _REPO_ROOT / "_bot_run.log"
|
||
if log.exists() and log.stat().st_size >= _log_max_bytes():
|
||
_clear_log()
|
||
except OSError as e: # noqa: BLE001
|
||
logger.warning(f"日志轮转检查失败: {type(e).__name__}: {e}")
|
||
|
||
|
||
def _start_log_watchdog() -> None:
|
||
"""后台线程按周期检查日志大小，超阈值直接清空（不归档），避免长期运行无限膨胀。"""
|
||
global _log_watchdog_started
|
||
if _log_watchdog_started:
|
||
return
|
||
_log_watchdog_started = True
|
||
_purge_legacy_archives() # 顺带清掉历史遗留的归档文件
|
||
|
||
def _loop() -> None:
|
||
while True:
|
||
time.sleep(_LOG_WATCH_INTERVAL)
|
||
_rotate_log_if_needed()
|
||
|
||
threading.Thread(target=_loop, name="hexi-log-watchdog", daemon=True).start()
|
||
|
||
|
||
_log_watchdog_started = False
|
||
|
||
|
||
def _tail_log_lines(
|
||
path: Path, limit: int, before: int | None
|
||
) -> tuple[list[str], int, int]:
|
||
"""从日志文件读取最近 limit 行（或 before 字节之前最近的 limit 行）。
|
||
|
||
返回 (lines, window_start_offset, file_size)。window_start_offset 可作为
|
||
下一批更早日志的 before；为 0 表示已到文件头。仅按 8KB 步进向后寻找行边界，
|
||
避免大日志全量 read_bytes。逐行 UTF-8 优先、GBK 兜底：兼容旧 GBK 日志与
|
||
切换为 UTF-8 后的新日志混存（保留 ANSI 颜色码，交给前端渲染颜色）。
|
||
"""
|
||
size = path.stat().st_size
|
||
end = size if before is None or before <= 0 or before > size else int(before)
|
||
if end <= 0:
|
||
return [], 0, size
|
||
start = 0
|
||
with open(path, "rb") as f:
|
||
pos = end
|
||
newline_count = 0
|
||
while pos > 0 and newline_count <= limit:
|
||
step = min(pos, 8192)
|
||
f.seek(pos - step)
|
||
chunk = f.read(step)
|
||
idx = chunk.rfind(b"\n")
|
||
if idx == -1:
|
||
pos -= step
|
||
continue
|
||
nl_abs = pos - step + idx
|
||
newline_count += 1
|
||
if newline_count > limit:
|
||
start = nl_abs + 1
|
||
break
|
||
pos = nl_abs
|
||
f.seek(start)
|
||
raw = f.read(end - start)
|
||
raw_lines = raw.split(b"\n")
|
||
if raw_lines and raw_lines[-1] == b"":
|
||
raw_lines.pop()
|
||
lines = []
|
||
for raw_line in raw_lines:
|
||
try:
|
||
line = raw_line.decode("utf-8")
|
||
except UnicodeDecodeError:
|
||
line = raw_line.decode("gbk", errors="replace")
|
||
lines.append(line.rstrip("\r"))
|
||
return lines, start, size
|
||
|
||
|
||
def _count_log_lines(path: Path) -> int:
|
||
"""分块统计全文件行数（仅换行计数，不全量载入）。"""
|
||
count = 0
|
||
with open(path, "rb") as f:
|
||
while True:
|
||
chunk = f.read(1 << 20)
|
||
if not chunk:
|
||
break
|
||
count += chunk.count(b"\n")
|
||
return count
|
||
|
||
|
||
def _schedule_bot_action(action: str) -> None:
|
||
"""1 秒后执行：stop 直接退出；restart 先拉起新进程再退出旧进程。"""
|
||
|
||
def _work() -> None:
|
||
time.sleep(1.0)
|
||
if action == "restart":
|
||
_spawn_bot()
|
||
time.sleep(1.0)
|
||
os._exit(0)
|
||
|
||
threading.Thread(target=_work, daemon=True).start()
|
||
|
||
|
||
def _uvicorn_access_debug(record: _logging.LogRecord) -> bool:
|
||
"""把 uvicorn 访问日志级别改为 DEBUG：默认 INFO 下不显示，开启 DEBUG 才可见。"""
|
||
if record.name == "uvicorn.access":
|
||
record.levelno = _logging.DEBUG
|
||
record.levelname = "DEBUG"
|
||
return True
|
||
|
||
|
||
class PasswordModel(BaseModel):
|
||
old_password: str
|
||
new_password: str
|
||
|
||
|
||
class PluginControlModel(BaseModel):
|
||
enabled: bool | None = None
|
||
chat: list[str] | None = None
|
||
|
||
|
||
class BotConfigModel(BaseModel):
|
||
superusers: list[str] | None = None
|
||
nickname: list[str] | None = None
|
||
debug: bool | None = None
|
||
log_level: str | None = None
|
||
log_max_mb: int | None = None
|
||
|
||
|
||
async def _first_bot():
|
||
"""取第一个 OneBot V11 bot，无则 None。"""
|
||
try:
|
||
from nonebot import get_adapter
|
||
|
||
bots = get_adapter(Adapter).bots
|
||
return next(iter(bots.values()), None)
|
||
except Exception: # noqa: BLE001
|
||
return None
|
||
|
||
|
||
def build_hub_app() -> FastAPI:
|
||
sync_admin()
|
||
|
||
app = FastAPI(title="HeXi Web Hub")
|
||
|
||
@app.post("/api/auth/token")
|
||
async def token_endpoint(form: OAuth2PasswordRequestForm = Depends()):
|
||
user_id = authenticate(form.username, form.password)
|
||
if user_id is None:
|
||
raise HTTPException(status_code=400, detail="用户名或密码错误")
|
||
token, expires_in = issue_token(user_id)
|
||
return {"access_token": token, "token_type": "bearer", "expires_in": expires_in}
|
||
|
||
@app.get("/api/auth/me")
|
||
async def me(user: dict = Depends(get_current_user)):
|
||
return {"ok": True, "username": user["username"]}
|
||
|
||
@app.post("/api/auth/logout")
|
||
async def logout(token: str = Depends(oauth2_scheme)):
|
||
if token and get_user_by_token(token):
|
||
revoke_token(token)
|
||
return {"ok": True}
|
||
|
||
@app.get("/api/plugins")
|
||
async def plugins(_: dict = Depends(get_current_user)):
|
||
return {"plugins": list_web_plugins()}
|
||
|
||
@app.get("/api/settings")
|
||
async def settings(user: dict = Depends(get_current_user)):
|
||
return {
|
||
"ok": True,
|
||
"user": {
|
||
"id": user["id"],
|
||
"username": user["username"],
|
||
"created_at": user.get("created_at", ""),
|
||
},
|
||
"plugins": list_web_plugins(),
|
||
"version": _hub_version(),
|
||
}
|
||
|
||
@app.get("/api/dashboard")
|
||
async def dashboard(_: dict = Depends(get_current_user)):
|
||
try:
|
||
data = await collect_dashboard()
|
||
except Exception as e: # noqa: BLE001
|
||
logger.warning(f"Dashboard 采集失败: {type(e).__name__}: {e}")
|
||
return {"ok": False, "msg": f"采集失败: {e}"}
|
||
return {"ok": True, **data}
|
||
|
||
@app.get("/api/plugins/catalog")
|
||
async def plugins_catalog(_: dict = Depends(get_current_user)):
|
||
"""全部 application/library 插件（含带配置项的 library）+ 控制面状态 + 是否带 Web 页面。"""
|
||
from hexi.core.plugin_control import list_plugins
|
||
from .web_config import has_schema
|
||
from .web_plugin_registry import get_web_plugin_by_module
|
||
|
||
items = list_plugins()
|
||
for it in items:
|
||
web = get_web_plugin_by_module(it["id"])
|
||
it["has_web"] = bool(web)
|
||
it["web_path"] = "/hub/" + web["id"] if web else None
|
||
it["has_config"] = has_schema(it["id"])
|
||
return {"plugins": items}
|
||
|
||
@app.get("/api/groups")
|
||
async def groups(_: dict = Depends(get_current_user)):
|
||
"""OneBot 当前群列表（分群控制用）。"""
|
||
bot = await _first_bot()
|
||
if bot is None:
|
||
return {"items": []}
|
||
try:
|
||
gl = await bot.get_group_list()
|
||
except Exception as e: # noqa: BLE001
|
||
logger.warning(f"获取群列表失败: {type(e).__name__}: {e}")
|
||
return {"items": []}
|
||
return {
|
||
"items": [
|
||
{"group_id": int(g["group_id"]), "group_name": g.get("group_name", "")}
|
||
for g in gl
|
||
]
|
||
}
|
||
|
||
@app.post("/api/plugins/{plugin_id}/global")
|
||
async def plugin_global(
|
||
plugin_id: str,
|
||
payload: PluginControlModel,
|
||
_: dict = Depends(get_current_user),
|
||
):
|
||
from hexi.core.plugin_control import set_global
|
||
|
||
ctl = set_global(plugin_id, enabled=payload.enabled, chat=payload.chat)
|
||
return {"ok": True, "control": ctl}
|
||
|
||
@app.post("/api/plugins/{plugin_id}/groups/{group_id}")
|
||
async def plugin_group(
|
||
plugin_id: str,
|
||
group_id: str,
|
||
payload: PluginControlModel,
|
||
_: dict = Depends(get_current_user),
|
||
):
|
||
from hexi.core.plugin_control import set_group
|
||
|
||
ctl = set_group(
|
||
plugin_id, group_id, enabled=payload.enabled, chat=payload.chat
|
||
)
|
||
return {"ok": True, "control": ctl}
|
||
|
||
@app.delete("/api/plugins/{plugin_id}/groups/{group_id}")
|
||
async def plugin_group_remove(
|
||
plugin_id: str,
|
||
group_id: str,
|
||
_: dict = Depends(get_current_user),
|
||
):
|
||
from hexi.core.plugin_control import remove_group
|
||
|
||
ctl = remove_group(plugin_id, group_id)
|
||
return {"ok": True, "control": ctl}
|
||
|
||
@app.get("/api/plugins/{plugin_id}/config")
|
||
async def plugin_config_get(
|
||
plugin_id: str, _: dict = Depends(get_current_user)
|
||
):
|
||
from .web_config import get_config
|
||
|
||
cfg = get_config(plugin_id)
|
||
if cfg is None:
|
||
return {"ok": False, "msg": "该插件未注册配置 schema"}
|
||
return {"ok": True, **cfg}
|
||
|
||
@app.post("/api/plugins/{plugin_id}/config")
|
||
async def plugin_config_set(
|
||
plugin_id: str,
|
||
payload: dict,
|
||
_: dict = Depends(get_current_user),
|
||
):
|
||
from .web_config import save_config
|
||
|
||
payload = payload or {}
|
||
if "revision" not in payload:
|
||
raise HTTPException(
|
||
status_code=status.HTTP_428_PRECONDITION_REQUIRED,
|
||
detail="缺少配置 revision，请先读取最新配置",
|
||
)
|
||
values = payload.get("values") or {}
|
||
try:
|
||
cfg = save_config(
|
||
plugin_id, values, expected_revision=int(payload["revision"])
|
||
)
|
||
except RuntimeError as e:
|
||
raise HTTPException(status_code=status.HTTP_409_CONFLICT, detail=str(e)) from e
|
||
except (TypeError, ValueError) as e:
|
||
raise HTTPException(status_code=status.HTTP_422_UNPROCESSABLE_ENTITY, detail=str(e)) from e
|
||
return {"ok": True, **cfg}
|
||
|
||
@app.get("/api/system/bot_config")
|
||
async def bot_config_get(_: dict = Depends(get_current_user)):
|
||
"""读取 bot 全局配置（SUPERUSERS / NICKNAME / DEBUG / LOG_LEVEL）。"""
|
||
from .bot_settings import current_values
|
||
|
||
return {"ok": True, **current_values()}
|
||
|
||
@app.post("/api/system/bot_config")
|
||
async def bot_config_set(
|
||
payload: BotConfigModel,
|
||
_: dict = Depends(get_current_user),
|
||
):
|
||
"""保存 bot 全局配置并尽量热应用到运行态。"""
|
||
from .bot_settings import save_bot_settings
|
||
|
||
try:
|
||
result = save_bot_settings(payload.dict(exclude_none=True))
|
||
except ValueError as e:
|
||
raise HTTPException(status_code=422, detail=str(e)) from e
|
||
return result
|
||
|
||
@app.post("/api/settings/password")
|
||
async def settings_password(
|
||
payload: PasswordModel,
|
||
token: str = Depends(oauth2_scheme),
|
||
user: dict = Depends(get_current_user),
|
||
):
|
||
if len(payload.new_password) < 6:
|
||
raise HTTPException(status_code=400, detail="新密码长度不能少于 6 位")
|
||
if not change_password(
|
||
user["id"], payload.old_password, payload.new_password, keep_token=token
|
||
):
|
||
raise HTTPException(status_code=400, detail="原密码错误")
|
||
return {"ok": True, "msg": "密码已修改"}
|
||
|
||
@app.get("/api/logs")
|
||
async def logs(
|
||
limit: int = 500,
|
||
before: int | None = None,
|
||
_: dict = Depends(get_current_user),
|
||
):
|
||
"""读取 bot 运行日志（优先 _bot_run.log）。
|
||
|
||
- before 不传：返回最近 limit 行，offset/end 为文件尾（SSE 以 end 续读）
|
||
- before 传字节偏移：返回该偏移之前最近 limit 行，offset 为这些行的起点，
|
||
继续把 offset 传给 before 即可向前翻页；offset==0 表示已到文件头。
|
||
"""
|
||
root = Path(__file__).resolve().parents[2] # 仓库根目录
|
||
candidates = [
|
||
root / "_bot_run.log",
|
||
root / "hexi" / "logs" / "bot.log",
|
||
]
|
||
path = next((p for p in candidates if p.exists()), None)
|
||
if path is None:
|
||
return {"ok": False, "msg": "未找到日志文件", "lines": [], "size": 0, "total": 0}
|
||
try:
|
||
lines, start, size = _tail_log_lines(path, max(1, int(limit)), before)
|
||
total = _count_log_lines(path)
|
||
except OSError as e: # noqa: BLE001
|
||
return {"ok": False, "msg": f"读取日志失败: {e}", "lines": [], "size": 0, "total": 0}
|
||
return {
|
||
"ok": True,
|
||
"file": path.name,
|
||
"size": size,
|
||
"end": size,
|
||
"offset": start,
|
||
"has_more": start > 0,
|
||
"lines": lines,
|
||
"total": total,
|
||
}
|
||
|
||
@app.get("/api/dashboard/stream")
|
||
async def dashboard_stream(
|
||
_: dict = Depends(get_current_user),
|
||
):
|
||
"""Dashboard 状态 SSE 实时推送（每 2 秒采集一次）。"""
|
||
|
||
async def gen():
|
||
while True:
|
||
try:
|
||
data = await collect_dashboard()
|
||
payload = {"ok": True, **data}
|
||
except Exception as e: # noqa: BLE001
|
||
payload = {"ok": False, "msg": f"采集失败: {e}"}
|
||
yield f"data: {json.dumps(payload, ensure_ascii=False)}\n\n"
|
||
await asyncio.sleep(2)
|
||
|
||
return StreamingResponse(gen(), media_type="text/event-stream")
|
||
|
||
@app.get("/api/logs/stream")
|
||
async def logs_stream(
|
||
since: int = 0,
|
||
_: dict = Depends(get_current_user),
|
||
):
|
||
"""SSE 实时日志流：从 since（字节偏移）增量推送新日志行。"""
|
||
root = Path(__file__).resolve().parents[2] # 仓库根目录
|
||
candidates = [
|
||
root / "_bot_run.log",
|
||
root / "hexi" / "logs" / "bot.log",
|
||
]
|
||
path = next((p for p in candidates if p.exists()), None)
|
||
if path is None:
|
||
raise HTTPException(status_code=404, detail="未找到日志文件")
|
||
|
||
async def gen():
|
||
current = max(0, since)
|
||
beat = 0
|
||
await asyncio.sleep(0)
|
||
while True:
|
||
try:
|
||
size = path.stat().st_size
|
||
except OSError:
|
||
await asyncio.sleep(1.0)
|
||
continue
|
||
if current > size:
|
||
current = 0 # 日志被轮转/截断
|
||
if current < size:
|
||
try:
|
||
with open(path, "rb") as f:
|
||
f.seek(current)
|
||
raw = f.read()
|
||
except OSError:
|
||
await asyncio.sleep(1.0)
|
||
continue
|
||
last_nl = raw.rfind(b"\n")
|
||
if last_nl != -1:
|
||
# 只处理完整行，结尾半行留给下次；保留 ANSI 颜色码供前端渲染
|
||
data = raw[: last_nl + 1]
|
||
raw_lines = data.split(b"\n")
|
||
if raw_lines and raw_lines[-1] == b"":
|
||
raw_lines = raw_lines[:-1]
|
||
current = current + last_nl + 1
|
||
for raw_line in raw_lines:
|
||
try:
|
||
line = raw_line.decode("utf-8")
|
||
except UnicodeDecodeError:
|
||
line = raw_line.decode("gbk", errors="replace")
|
||
payload = {"line": line.rstrip("\r"), "offset": current}
|
||
yield f"data: {json.dumps(payload, ensure_ascii=False)}\n\n"
|
||
await asyncio.sleep(0.5)
|
||
beat += 1
|
||
if beat >= 30: # 每 ~15s 一次心跳保活
|
||
beat = 0
|
||
yield ": ping\n\n"
|
||
|
||
return StreamingResponse(gen(), media_type="text/event-stream")
|
||
|
||
@app.post("/api/system/bot")
|
||
async def bot_action(
|
||
payload: dict,
|
||
_: dict = Depends(get_current_user),
|
||
):
|
||
"""停止/重启 bot 进程（stop 直接退出；restart 先拉起新进程再退出旧进程）。"""
|
||
action = (payload or {}).get("action", "")
|
||
if action not in {"stop", "restart"}:
|
||
raise HTTPException(status_code=400, detail="action 必须是 stop 或 restart")
|
||
_schedule_bot_action(action)
|
||
label = "停止" if action == "stop" else "重启"
|
||
return {"ok": True, "msg": f"已请求{label} bot，约 1 秒后执行"}
|
||
|
||
assets = WEB_DIST / "assets"
|
||
if assets.exists():
|
||
app.mount("/assets", StaticFiles(directory=str(assets)), name="hub_assets")
|
||
|
||
@app.get("/")
|
||
async def index():
|
||
if (WEB_DIST / "index.html").exists():
|
||
return FileResponse(WEB_DIST / "index.html")
|
||
return HTMLResponse(
|
||
"<h1>HeXi Web Hub</h1><p>前端未构建，请在 <code>hexi/web</code> 执行 "
|
||
"<code>npm run build</code>。</p>"
|
||
)
|
||
|
||
@app.get("/{path:path}")
|
||
async def spa(path: str):
|
||
target = (WEB_DIST / path).resolve()
|
||
if path and target.is_file() and target.is_relative_to(WEB_DIST.resolve()):
|
||
return FileResponse(target)
|
||
if (WEB_DIST / "index.html").exists():
|
||
return FileResponse(WEB_DIST / "index.html")
|
||
raise HTTPException(status_code=404, detail="页面不存在")
|
||
|
||
return app
|
||
|
||
|
||
def _mount_all_web_plugins() -> None:
|
||
"""启动时挂载所有已注册插件的 API 到 /api/<id>。"""
|
||
try:
|
||
from nonebot import get_app
|
||
|
||
for plugin in list_web_plugins():
|
||
builder = get_web_plugin_builder(plugin["id"])
|
||
if not builder:
|
||
continue
|
||
try:
|
||
sub_app = builder()
|
||
if sub_app is not None:
|
||
get_app().mount("/api/" + plugin["id"], sub_app)
|
||
logger.info(f"Web 插件 API 已挂载: /api/{plugin['id']}")
|
||
except Exception as e: # noqa: BLE001
|
||
logger.warning(f"Web 插件 {plugin['id']} 挂载失败: {type(e).__name__}: {e}")
|
||
except Exception as e: # noqa: BLE001
|
||
logger.warning(f"Web 插件自动挂载失败: {type(e).__name__}: {e}")
|
||
|
||
|
||
def mount_hub() -> None:
|
||
try:
|
||
from nonebot import get_app
|
||
|
||
get_app().mount("/hub", build_hub_app())
|
||
logger.info("统一 Web 管理系统已挂载: /hub")
|
||
except Exception as e: # noqa: BLE001
|
||
logger.warning(f"统一 Web 管理系统挂载失败: {type(e).__name__}: {e}")
|
||
|
||
|
||
mount_hub()
|
||
_start_log_watchdog()
|
||
|
||
|
||
@get_driver().on_startup
|
||
async def _startup_mount_web_plugins() -> None:
|
||
"""等所有插件 import 完成后，注册表就绪，再统一挂载各插件 API。"""
|
||
_mount_all_web_plugins()
|
||
|
||
|
||
@get_driver().on_startup
|
||
async def _downgrade_uvicorn_access_logs() -> None:
|
||
"""把 uvicorn.access 日志降级为 DEBUG（经 loguru 后按日志等级过滤）。"""
|
||
_logging.getLogger("uvicorn.access").addFilter(_uvicorn_access_debug) |