entari-plugin-webui 1.0.0__py3-none-any.whl

entari_plugin_webui/__init__.py

@@ -0,0 +1,131 @@
+"""Entari Plugin: WebUI 服务（重设计版）"""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from arclet.entari import plugin
+from arclet.entari.event.lifespan import Startup
+from arclet.entari.event.send import SendResponse
+from arclet.entari.plugin import PluginRole, plugin_config
+from entari_plugin_server import add_route, add_websocket_route, replace_asgi, server
+from fastapi import Request
+from fastapi.staticfiles import StaticFiles
+from starlette.responses import FileResponse, Response
+
+from .config import Config
+from .core.extension import MenuItem as MenuItem
+from .core.extension import WebUIExtension as WebUIExtension
+from .core.extension import get_all_extension_routes
+from .core.extension import webui_extend as webui_extend
+from .core.security import (
+    LoginThrottle,
+    generate_random_password,
+    hash_password,
+    is_local_deployment,
+    parse_rate_limit,
+    set_local_mode,
+)
+from .core.session import SessionStore
+from .utils import logger
+
+__version__ = "1.0.0"
+_STATIC_DIR = Path(__file__).parent / "static"
+_FRONTEND_DIR = _STATIC_DIR / "frontend"
+
+webui_config = plugin_config(Config, bind=True)
+
+from .adapter import WebUIAdapter
+from .api import create_app as _create_app  # noqa: E402
+from .api import logs  # noqa: F401
+from .models.stats import MessageStat  # noqa: F401
+from .services.stats_service import increment  # noqa: PLC0415
+
+_session_store: SessionStore = SessionStore(ttl=webui_config.session_ttl)
+_login_throttle = LoginThrottle(*parse_rate_limit(webui_config.login_rate_limit))
+
+if not server.path:
+    logger.warning("未检测到 Server 插件的 path 配置，WebUI 可能无法正常工作")
+    logger.warning("已自动设置 Server 插件的 path 为 /satori")
+    server.path = "/satori"
+
+server.apply(WebUIAdapter())
+
+
+plugin.metadata(
+    "WebUI 服务",
+    PluginRole.UTILITY,
+    [{"name": "RF-Tar-Railt", "email": "rf_tar_railt@qq.com"}],
+    __version__,
+    description="基于 Vite + Vue 3 + Element Plus 的可视化管理面板",
+    urls={"homepage": "https://github.com/ArcletProject/entari-plugin-webui"},
+    config=Config,
+)
+
+
+# ---------- SPA fallback handlers ----------
+async def _root(request: Request) -> Response:
+    if not _FRONTEND_DIR.exists():
+        return Response(
+            content="Frontend not built. Run 'pdm run build-frontend'.",
+            status_code=503,
+        )
+    path = request.url.path.lstrip("/")
+    file = _FRONTEND_DIR / (path or "index.html")
+    if file.exists():
+        return FileResponse(file)
+    return Response(status_code=404)
+
+
+replace_asgi(app := _create_app())
+
+if _FRONTEND_DIR.exists() and (_FRONTEND_DIR / "assets").exists():
+    app.mount("/assets", StaticFiles(directory=_FRONTEND_DIR / "assets", html=True))
+
+add_route("/", methods=["GET"], include_in_schema=False)(_root)
+add_route("/favicon.ico", methods=["GET"], include_in_schema=False)(_root)
+add_route("/favicon.svg", methods=["GET"], include_in_schema=False)(_root)
+
+
+# ---------- SendResponse listener (message counting) ----------
+@plugin.listen(SendResponse)
+async def _on_message_sent(event: SendResponse) -> None:
+    platform = event.account.platform
+    try:
+        await increment(platform)
+    except Exception:  # noqa: BLE001
+        logger.debug("消息计数失败")
+
+
+# ---------- Startup listener ----------
+@plugin.listen(Startup, priority=100)
+async def _on_startup() -> None:
+    is_local = is_local_deployment(server.host)
+    set_local_mode(is_local)
+    if is_local:
+        logger.info("本地部署模式，无需认证")
+    else:
+        logger.info("远程部署模式，需要认证")
+        if not webui_config.password:
+            raw = generate_random_password(16)
+            webui_config.password = hash_password(raw)
+            logger.warning("已生成管理员密码：" + raw)
+
+    import arclet.entari.logger as entari_log
+    from loguru import logger as loguru_logger
+
+    from .core.log_stream import LogWriter, get_log_buffer
+
+    log_buffer = get_log_buffer()
+    loguru_logger.add(
+        LogWriter(log_buffer), level=0, diagnose=True, backtrace=True, colorize=True, filter=entari_log.default_filter
+    )  # type: ignore[call-overload]
+
+    routes, ws_routes = get_all_extension_routes()
+    for r in routes:
+        add_route(r.path, methods=r.methods)(r.handler)
+    for w in ws_routes:
+        add_websocket_route(w.path)(w.handler)
+
+    host = server.host or "127.0.0.1"
+    logger.info(f"管理面板已启动: http://{host}:{server.port}/")

entari_plugin_webui/adapter.py

@@ -0,0 +1,232 @@
+from __future__ import annotations
+
+import asyncio
+from datetime import datetime
+from secrets import token_hex
+
+from launart import Launart, any_completed
+from launart.status import Phase
+from satori import Api, Event, EventType, LoginStatus
+from satori.exception import ActionFailed
+from satori.model import Channel, ChannelType, Login, MessageObject, User
+from satori.parser import Element, parse
+from satori.server import Request
+from satori.server.adapter import Adapter as BaseAdapter
+from satori.server.route import MessageParam
+from satori.utils import decode, encode
+from starlette.responses import JSONResponse, Response
+from starlette.routing import WebSocketRoute
+from starlette.websockets import WebSocket
+
+from .core.security import is_local_mode
+
+
+def serialize_element(element: Element):
+    return {
+        "type": element.type,
+        "attrs": element.attrs,
+        "children": [serialize_element(child) for child in element.children],
+    }
+
+
+def deserialize_element(data: dict) -> Element:
+    return Element(
+        data["type"],
+        data.get("attrs", {}),
+        *(deserialize_element(child) for child in data.get("children", [])),
+    )
+
+
+def elements_to_content(elements: list[dict] | None) -> str:
+    if not elements:
+        return ""
+    return "".join(str(deserialize_element(e)) for e in elements)
+
+
+async def message_receive(raw: dict, conn: WebsocketConnection):
+    peer_type = raw.get("peer_type", "user")
+    peer_id = f"private:{conn.user_id}" if peer_type == "user" else (raw.get("peer_id") or f"channel:{token_hex(8)}")
+    message_id = raw["message_id"]
+    message_content = raw.get("message_content") or elements_to_content(raw.get("elements"))
+    channel = Channel(peer_id, ChannelType.DIRECT if peer_type == "user" else ChannelType.TEXT)
+    return Event(
+        EventType.MESSAGE_CREATED,
+        datetime.now(),
+        conn.adapter.logins[conn.session_id],
+        channel=channel,
+        user=User(conn.user_id, conn.user_id),
+        message=MessageObject(id=message_id, content=message_content),
+    )
+
+
+class WebsocketConnection:
+    connection: WebSocket
+
+    def __init__(self, adapter: WebUIAdapter, connection: WebSocket, session_id: str = "entari"):
+        self.adapter = adapter
+        self.connection = connection
+        self.session_id = session_id
+        self.user_id: str = f"user_{token_hex(8)}"
+        self.close_signal: asyncio.Event = asyncio.Event()
+        self.response_waiters: dict[str, asyncio.Future] = {}
+
+    @property
+    def alive(self) -> bool:
+        return not self.close_signal.is_set()
+
+    async def message_receive(self):
+
+        while True:
+            message = await self.connection.receive()
+
+            if message["type"] == "websocket.disconnect":
+                break
+            yield self, decode(message["text"])
+        self.close_signal.set()
+
+    async def message_handle(self):
+        async for _, data in self.message_receive():
+            if token := data.get("token"):
+                if token in self.response_waiters:
+                    self.response_waiters[token].set_result(data)
+                continue
+            event_type = data.get("type")
+            if event_type == "message_create":
+                event = await message_receive(data["data"], self)
+            else:
+                event = Event(EventType.INTERNAL, datetime.now(), self.adapter.logins[self.session_id])
+            event._type = event_type
+            event._data = data.get("data")
+            asyncio.create_task(self.adapter.server.post(event))
+
+    async def connection_closed(self):
+        self.close_signal.set()
+
+    async def call_api(self, action: str, params: dict | None = None) -> dict:
+        future = asyncio.get_running_loop().create_future()
+        token = token_hex(16)
+        self.response_waiters[token] = future
+        try:
+            await self.send({"action": action, "data": params or {}, "token": token})
+            result = await asyncio.wait_for(future, timeout=60)
+        finally:
+            self.response_waiters.pop(token, None)
+        if result["status"] != "ok":
+            raise ActionFailed(result.get("error", "Unknown error"), result)
+        return result.get("data", {})
+
+    async def send(self, payload: dict) -> None:
+        return await self.connection.send_text(encode(payload))
+
+
+def apply(adapter: WebUIAdapter):
+    @adapter.route(Api.MESSAGE_CREATE)
+    async def _message_create(request: Request[MessageParam]):
+        conn = adapter.connections[request.self_id]
+        channel_id = request.params["channel_id"]
+        if "elements" in request.params:
+            elements = request.params["elements"]
+            content = elements_to_content(elements)
+        else:
+            content = request.params["content"]
+            elements = [serialize_element(e) for e in parse(content)]
+        result = await conn.call_api("message_create", {"channel_id": channel_id, "elements": elements})
+        return [MessageObject(result["id"], content)]
+
+
+class WebUIAdapter(BaseAdapter):
+    def __init__(self):
+        super().__init__()
+        self.connections: dict[str, WebsocketConnection] = {}
+        self.logins: dict[str, Login] = {}
+
+        apply(self)
+
+    def ensure(self, platform: str, self_id: str) -> bool:
+        return platform == "webui" and self_id in self.connections
+
+    async def get_logins(self) -> list[Login]:
+        logins = list(self.logins.values())
+        for index, login in enumerate(logins):
+            login.sn = index
+        return logins
+
+    @property
+    def required(self) -> set[str]:
+        return {"satori-python.server", "asgi.service/uvicorn"}
+
+    @property
+    def stages(self) -> set[Phase]:
+        return {"preparing", "blocking", "cleanup"}
+
+    def get_routes(self):
+        return [
+            WebSocketRoute("/api/chat", self.websocket_server_handler),
+        ]
+
+    async def websocket_server_handler(self, ws: WebSocket):
+        sid = None
+        if not is_local_mode():
+            sid = ws.cookies.get("webui_sid")
+            from entari_plugin_webui import _session_store
+
+            if _session_store.get(sid) is None:
+                await ws.close(code=1008, reason="Invalid session")
+                return
+
+        sid = sid or f"entari_{token_hex(8)}"
+        if sid in self.connections:
+            old = self.connections[sid]
+            if old.alive:
+                await ws.close(code=1008, reason="Duplicate connection")
+                return
+            self.connections.pop(sid, None)
+
+        await ws.accept()
+        conn = WebsocketConnection(self, ws, session_id=sid)
+        self.connections[sid] = conn
+
+        if sid not in self.logins:
+            self.logins[sid] = Login(
+                platform="webui",
+                user=User(id=sid, name="Entari"),
+                status=LoginStatus.ONLINE,
+            )
+            await self.server.post(Event(EventType.LOGIN_ADDED, datetime.now(), self.logins[sid]))
+        else:
+            self.logins[sid].status = LoginStatus.ONLINE
+            await self.server.post(Event(EventType.LOGIN_UPDATED, datetime.now(), self.logins[sid]))
+
+        try:
+            await any_completed(
+                conn.message_handle(),
+                conn.close_signal.wait(),
+            )
+        finally:
+            await conn.connection_closed()
+            self.connections.pop(sid, None)
+            if conn.response_waiters:
+                for future in conn.response_waiters.values():
+                    future.cancel()
+            self.logins[sid].status = LoginStatus.OFFLINE
+            await self.server.post(Event(EventType.LOGIN_REMOVED, datetime.now(), self.logins[sid]))
+
+    def get_platform(self) -> str:
+        return "webui"
+
+    async def handle_internal(self, request: Request, path: str) -> Response:
+        if path.startswith("_api"):
+            self_id = request.self_id
+            return JSONResponse(await self.connections[self_id].call_api(path[5:], await request.origin.json()))
+        async with self.server.session.get(path) as resp:
+            return Response(await resp.read())
+
+    async def launch(self, manager: Launart):
+        async with self.stage("preparing"):
+            pass
+
+        async with self.stage("blocking"):
+            await manager.status.wait_for_sigexit()
+
+        async with self.stage("cleanup"):
+            pass

entari_plugin_webui/api/__init__.py

@@ -0,0 +1,3 @@
+from .router import create_app
+
+__all__ = ["create_app"]

entari_plugin_webui/api/auth.py

@@ -0,0 +1,107 @@
+from __future__ import annotations
+
+from fastapi import APIRouter, Depends, HTTPException, Request, status
+from pydantic import BaseModel, Field
+from starlette.responses import JSONResponse
+
+from entari_plugin_webui import webui_config
+
+from ..core.audit import audit
+from ..core.error import AuthRequired, TooManyRequests
+from ..core.security import (
+    hash_password,
+    is_local_mode,
+    verify_password,
+)
+from ..core.session import SessionStore
+from .deps import get_session_store, require_auth
+
+router = APIRouter(prefix="/api/auth", tags=["auth"])
+
+_COOKIE = "webui_sid"
+
+
+class LoginRequest(BaseModel):
+    password: str = Field(min_length=1)
+
+
+class PasswordRequest(BaseModel):
+    old_password: str
+    new_password: str = Field(min_length=6)
+
+
+def _client_ip(request: Request) -> str:
+    return request.client.host if request.client else "unknown"
+
+
+@router.get("/check")
+async def check_auth():
+    return {"local_mode": is_local_mode(), "initialized": bool(webui_config.password)}
+
+
+@router.post("/login")
+async def login(body: LoginRequest, request: Request, store: SessionStore = Depends(get_session_store)):
+    ip = _client_ip(request)
+    from .. import _login_throttle  # type: ignore  # noqa: PLC0415
+
+    if is_local_mode():
+        sid = store.create(ip=ip)
+        return _json_with_cookie({"success": True, "local_mode": True}, sid)
+
+    if _login_throttle.is_limited(ip):
+        audit("login.failed", ip=ip, reason="rate_limited")
+        raise TooManyRequests(retry_after=_login_throttle.retry_after(ip), message="尝试过于频繁，请稍后再试")
+
+    if not webui_config.password:
+        raise HTTPException(status.HTTP_500_INTERNAL_SERVER_ERROR, "管理员密码尚未初始化")
+
+    if not verify_password(body.password, webui_config.password):
+        _login_throttle.record_failure(ip)
+        audit("login.failed", ip=ip, reason="wrong_password")
+        raise AuthRequired(message="密码错误")
+
+    _login_throttle.reset(ip)
+    sid = store.create(ip=ip)
+    audit("login.success", ip=ip)
+    return _json_with_cookie({"success": True, "local_mode": False}, sid)
+
+
+@router.post("/logout")
+async def logout(request: Request, store: SessionStore = Depends(get_session_store)):
+    sid = request.cookies.get(_COOKIE)
+    if sid:
+        store.destroy(sid)
+    if not is_local_mode():
+        audit("logout", ip=_client_ip(request))
+    resp = JSONResponse({"success": True})
+    resp.delete_cookie(_COOKIE, path="/")
+    return resp
+
+
+@router.put("/password")
+async def change_password(
+    body: PasswordRequest,
+    request: Request,
+    _sess=Depends(require_auth),
+):
+    if not is_local_mode() and not verify_password(body.old_password, webui_config.password):
+        audit("password.change.failed", ip=_client_ip(request), reason="wrong_old")
+        raise AuthRequired(message="旧密码错误")
+    webui_config.password = hash_password(body.new_password)
+    audit("password.change", ip=_client_ip(request))
+    return {"success": True}
+
+
+def _json_with_cookie(payload: dict, sid: str) -> JSONResponse:
+    resp = JSONResponse(payload)
+    secure = True
+    resp.set_cookie(
+        _COOKIE,
+        sid,
+        httponly=True,
+        samesite="lax",
+        secure=secure,
+        max_age=webui_config.session_ttl,
+        path="/",
+    )
+    return resp

entari_plugin_webui/api/config.py

@@ -0,0 +1,39 @@
+from __future__ import annotations
+
+from fastapi import APIRouter, Depends
+from pydantic import BaseModel
+
+from ..services.config_service import (
+    get_schema_for_section,
+    get_section,
+    list_sections,
+    update_section,
+)
+from .deps import require_auth
+
+router = APIRouter(prefix="/api/config", tags=["config"], dependencies=[Depends(require_auth)])
+
+
+class SectionBody(BaseModel):
+    data: dict | list
+
+
+@router.get("/{section}/schema")
+async def schema(section: str):
+    return {"success": True, "section": section, **get_schema_for_section(section)}
+
+
+@router.get("")
+async def list_():
+    return {"success": True, **list_sections()}
+
+
+@router.get("/{section}")
+async def get_(section: str):
+    return {"success": True, "section": section, "data": get_section(section)}
+
+
+@router.put("/{section}")
+async def put_(section: str, body: SectionBody):
+    update_section(section, body.data)
+    return {"success": True, "message": "已保存"}

entari_plugin_webui/api/deps.py

@@ -0,0 +1,24 @@
+from __future__ import annotations
+
+from fastapi import Depends, Request
+
+from ..core.error import AuthRequired
+from ..core.security import is_local_mode
+from ..core.session import Session, SessionStore
+
+
+def get_session_store() -> SessionStore:
+    from .. import _session_store  # type: ignore  # noqa: PLC0415
+
+    return _session_store
+
+
+def require_auth(request: Request, store: SessionStore = Depends(get_session_store)) -> Session | None:
+    if is_local_mode():
+        return None
+    sid = request.cookies.get("webui_sid")
+    sess = store.get(sid)
+    if sess is None:
+        raise AuthRequired("未登录或会话已过期")
+    store.refresh_if_needed(sess)
+    return sess

entari_plugin_webui/api/extensions.py

@@ -0,0 +1,21 @@
+from __future__ import annotations
+
+from fastapi import APIRouter, Depends
+
+from ..api.deps import require_auth
+from ..core.extension import get_all_menus, get_all_pages
+from ..core.i18n import I18nRegistry
+from ..core.permissions import get_permissions
+
+router = APIRouter(prefix="/api/extensions", tags=["extensions"], dependencies=[Depends(require_auth)])
+
+
+@router.get("/manifest")
+async def manifest():
+    return {
+        "success": True,
+        "menus": get_all_menus(),
+        "pages": get_all_pages(),
+        "i18n": I18nRegistry.all(),
+        "permissions": get_permissions(),
+    }

entari_plugin_webui/api/health.py

@@ -0,0 +1,21 @@
+from __future__ import annotations
+
+from datetime import datetime
+from pathlib import Path
+
+from fastapi import APIRouter
+
+router = APIRouter(prefix="/api", tags=["health"])
+
+_START = datetime.now()
+
+
+@router.get("/health")
+async def health() -> dict:
+
+    frontend_built = (Path(__file__).resolve().parent.parent / "static" / "frontend" / "index.html").exists()
+    return {
+        "status": "ok",
+        "uptime_seconds": int((datetime.now() - _START).total_seconds()),
+        "frontend_built": frontend_built,
+    }

entari_plugin_webui/api/logs.py

@@ -0,0 +1,40 @@
+from __future__ import annotations
+
+import asyncio
+
+from entari_plugin_server import add_websocket_route
+from starlette.websockets import WebSocket, WebSocketDisconnect
+
+from ..core.log_stream import get_log_buffer
+from ..core.security import is_local_mode
+
+
+@add_websocket_route("/ws/logs")
+async def websocket_logs(ws: WebSocket) -> None:
+    if not is_local_mode():
+        sid = ws.cookies.get("webui_sid")
+        from entari_plugin_webui import _session_store
+
+        if _session_store.get(sid) is None:
+            await ws.close(code=1008)
+            return
+
+    await ws.accept()
+    buffer = get_log_buffer()
+    history_data, last_pos = buffer.get_recent(100)
+    await ws.send_json({"type": "history", "data": history_data})
+    try:
+        while True:
+            text, last_pos = buffer.get_new_since(last_pos)
+            if text:
+                await ws.send_json({"type": "log", "data": text})
+            await asyncio.sleep(0.5)
+    except (WebSocketDisconnect, asyncio.CancelledError):
+        pass
+    except Exception:  # noqa: BLE001
+        pass
+    finally:
+        from contextlib import suppress
+
+        with suppress(Exception):
+            await ws.close()

entari_plugin_webui/api/market.py

@@ -0,0 +1,63 @@
+from __future__ import annotations
+
+from fastapi import APIRouter, Depends
+from fastapi.responses import JSONResponse
+from pydantic import BaseModel
+from starlette.status import HTTP_404_NOT_FOUND
+
+from ..api.deps import require_auth
+from ..core.error import PluginNotFound
+from ..services.market_service import (
+    get_plugin,
+    get_task,
+    list_plugins,
+    start_install,
+    start_uninstall,
+)
+
+router = APIRouter(prefix="/api/market", tags=["market"], dependencies=[Depends(require_auth)])
+
+
+class NameBody(BaseModel):
+    name: str
+
+
+@router.get("/plugins")
+async def list_():
+    return {"success": True, **(await list_plugins())}
+
+
+@router.get("/plugins/{name}")
+async def detail(name: str):
+    p = await get_plugin(name)
+    if p is None:
+        raise PluginNotFound(name)
+    return {"success": True, "data": p}
+
+
+@router.post("/install")
+async def install(body: NameBody):
+    tid = await start_install(body.name)
+    return {"success": True, "task_id": tid}
+
+
+@router.post("/uninstall")
+async def uninstall(body: NameBody):
+    tid = await start_uninstall(body.name)
+    return {"success": True, "task_id": tid}
+
+
+@router.get("/tasks/{task_id}")
+async def task(task_id: str):
+    t = get_task(task_id)
+    if t is None:
+        return JSONResponse({"success": False, "code": "task_not_found"}, status_code=HTTP_404_NOT_FOUND)
+    return {
+        "success": True,
+        "task_id": t.task_id,
+        "pip_name": t.pip_name,
+        "action": t.action,
+        "status": t.status,
+        "percent": t.percent,
+        "message": t.message,
+    }