ErisPulse-ConnHub 0.1.0__tar.gz

erispulse_connhub-0.1.0/ConnHub/Config.py

@@ -0,0 +1,76 @@
+from dataclasses import dataclass, field
+
+from ErisPulse.Core.Bases import BaseConfig
+
+
+@dataclass
+class ConnHubConfig(BaseConfig):
+
+    enabled: bool = field(
+        default=True,
+        metadata={
+            "description": {"i18n": "ConnHub.enabled", "default": "是否启用模块"},
+            "ui": {"widget": "switch", "group": "basic", "order": 1},
+        },
+    )
+    api_enabled: bool = field(
+        default=True,
+        metadata={
+            "description": {"i18n": "ConnHub.api_enabled", "default": "启用 HTTP API 与 SSE 事件流"},
+            "ui": {"widget": "switch", "group": "api", "order": 2},
+        },
+    )
+    panel_enabled: bool = field(
+        default=True,
+        metadata={
+            "description": {"i18n": "ConnHub.panel_enabled", "default": "启用内置连接面板网页"},
+            "ui": {"widget": "switch", "group": "api", "order": 3},
+        },
+    )
+    allow_force_close: bool = field(
+        default=False,
+        metadata={
+            "description": {"i18n": "ConnHub.allow_force_close", "default": "允许关闭其他模块归属的连接（跳过归属校验）"},
+            "ui": {"widget": "switch", "group": "api", "order": 4},
+        },
+    )
+    snapshot_interval_secs: int = field(
+        default=15,
+        metadata={
+            "description": {"i18n": "ConnHub.snapshot_interval_secs", "default": "向面板推送全量快照的间隔秒数（0 关闭）"},
+            "ui": {"widget": "number", "group": "api", "order": 5},
+        },
+    )
+    broadcast_timeout: float = field(
+        default=10.0,
+        metadata={
+            "description": {"i18n": "ConnHub.broadcast_timeout", "default": "广播时单条连接的发送超时秒数"},
+            "ui": {"widget": "number", "group": "api", "order": 6},
+        },
+    )
+    top_max: int = field(
+        default=20,
+        metadata={
+            "description": {"i18n": "ConnHub.top_max", "default": "连接列表单次展示的最大条数"},
+            "ui": {"widget": "number", "group": "basic", "order": 7},
+        },
+    )
+    render_card: bool = field(
+        default=True,
+        metadata={
+            "description": {"i18n": "ConnHub.render_card", "default": "命令输出用 Takumi 渲染为卡片（不可用时降级文本）"},
+            "ui": {"widget": "switch", "group": "render", "order": 8},
+        },
+    )
+    theme: str = field(
+        default="auto",
+        metadata={
+            "description": {"i18n": "ConnHub.theme", "default": "卡片配色 (auto=按时间自动切深浅色)"},
+            "ui": {
+                "widget": "select",
+                "options": ["auto", "light", "dark"],
+                "group": "render",
+                "order": 9,
+            },
+        },
+    )

erispulse_connhub-0.1.0/ConnHub/Core.py

@@ -0,0 +1,272 @@
+import asyncio
+
+from ErisPulse import connections, i18n, respond, router, sdk
+from ErisPulse.Core.Bases import BaseModule, ModuleMeta
+from ErisPulse.Core.Event import command
+from ErisPulse.loaders import ModuleLoadStrategy
+
+from .Config import ConnHubConfig
+from .I18n import ConnHubI18n
+from .Panel import PANEL_HTML
+from .Service import VALID_KINDS, ConnHubService
+from .Visualizer import CardVisualizer
+
+
+class Main(BaseModule):
+
+    ConfigClass = ConnHubConfig
+    I18nClass = ConnHubI18n
+
+    def __init__(self):
+        self.sdk = sdk
+        self.logger = sdk.logger.get_child("ConnHub")
+        self._service = ConnHubService(connections, self.logger)
+        self._viz = CardVisualizer(sdk, self.logger)
+        self._snapshot_task = None
+
+    @staticmethod
+    def get_load_strategy() -> ModuleLoadStrategy:
+        return ModuleLoadStrategy(lazy_load=False, priority=30)
+
+    @staticmethod
+    def get_meta() -> ModuleMeta:
+        return ModuleMeta(
+            name="ConnHub",
+            description="连接中心：查看/广播/关闭框架登记的 WS/SSE 连接，提供 HTTP API 与实时面板",
+            version="0.1.0",
+            author="ErisPulse-devs",
+            group="运维",
+            tags=["连接池", "广播", "SSE", "面板"],
+            min_sdk_version="2.10.0",
+        )
+
+    async def on_load(self, event: dict) -> bool:
+        if not self.cfg.enabled:
+            self.logger.info("连接中心未启用（enabled=false）")
+            return True
+
+        self._register_lifecycle()
+        self._register_commands()
+        if self.cfg.api_enabled:
+            self._register_routes()
+        self._snapshot_task = self.spawn(self._snapshot_loop())
+        self.logger.info(i18n.t("ConnHub.module_loaded", event=event))
+        return True
+
+    async def on_unload(self, event: dict) -> bool:
+        if self._snapshot_task is not None:
+            self._snapshot_task.cancel()
+            await asyncio.gather(self._snapshot_task, return_exceptions=True)
+            self._snapshot_task = None
+        self.logger.info(i18n.t("ConnHub.module_unloaded", event=event))
+        return True
+
+    def _register_lifecycle(self):
+        @sdk.lifecycle.on("connection.registered")
+        async def _on_registered(data):
+            self._service.on_connection_event("registered")
+            await self._push_event("registered", data)
+
+        @sdk.lifecycle.on("connection.unregistered")
+        async def _on_unregistered(data):
+            self._service.on_connection_event("unregistered")
+            await self._push_event("unregistered", data)
+
+        @sdk.lifecycle.on("connection.group.joined")
+        async def _on_group_joined(data):
+            await self._push_event("group.joined", data)
+
+        @sdk.lifecycle.on("connection.group.left")
+        async def _on_group_left(data):
+            await self._push_event("group.left", data)
+
+    async def _push_event(self, action: str, data: dict):
+        payload = ConnHubService.event_payload(action, data)
+        await self._broadcast_to_watchers(payload)
+
+    async def _broadcast_to_watchers(self, payload):
+        try:
+            await connections.broadcast(
+                payload,
+                namespace="ConnHub",
+                kind="sse",
+                timeout=self.cfg.broadcast_timeout,
+            )
+        except Exception as e:
+            self.logger.warning(f"推送事件到面板失败: {e}")
+
+    async def _snapshot_loop(self):
+        while True:
+            try:
+                interval = int(self.cfg.snapshot_interval_secs)
+                if interval <= 0:
+                    await asyncio.sleep(5)
+                    continue
+                await asyncio.sleep(interval)
+                await self._broadcast_to_watchers(self._service.snapshot_payload())
+            except asyncio.CancelledError:
+                raise
+            except Exception as e:
+                self.logger.warning(f"快照推送异常: {e}")
+                await asyncio.sleep(5)
+
+    def _register_commands(self):
+        @command("conn", master=True, help="连接中心管理")
+        async def conn_handler(event):
+            await event.reply(
+                "用法: /conn list [kind] | /conn stats | /conn group add|remove <id> <组名> | "
+                "/conn broadcast <组名|*> <消息> | /conn close <id>"
+            )
+
+        @command("conn list", master=True, help="列出登记中的连接", args="[kind:str]")
+        async def conn_list_handler(event, kind: str = ""):
+            if kind and kind not in VALID_KINDS:
+                await event.reply(i18n.t("ConnHub.invalid_kind", kind=kind))
+                return
+            await self._reply_card(
+                event,
+                lambda: self._service.list_card_html(kind or None, self.cfg.top_max, self._viz),
+                self._service.format_list(kind or None, self.cfg.top_max),
+            )
+
+        @command("conn stats", master=True, help="查看连接池统计")
+        async def conn_stats_handler(event):
+            await self._reply_card(
+                event,
+                lambda: self._service.stats_card_html(self._viz),
+                self._service.format_stats(),
+            )
+
+        @command("conn group add", master=True, help="把连接加入分组", args="<cid:str> <group:str>")
+        async def conn_group_add_handler(event, cid: str, group: str):
+            try:
+                self._service.assign(cid, group)
+            except Exception as e:
+                await event.reply(self._conn_error_text(e, cid))
+                return
+            await event.reply(i18n.t("ConnHub.group_assigned", id=cid, group=group))
+
+        @command("conn group remove", master=True, help="把连接移出分组", args="<cid:str> <group:str>")
+        async def conn_group_remove_handler(event, cid: str, group: str):
+            try:
+                self._service.dismiss(cid, group)
+            except Exception as e:
+                await event.reply(self._conn_error_text(e, cid))
+                return
+            await event.reply(i18n.t("ConnHub.group_dismissed", id=cid, group=group))
+
+        @command("conn broadcast", master=True, help="向分组广播消息", args="<group:str> <text:rest>")
+        async def conn_broadcast_handler(event, group: str, text: str):
+            result = await self._service.broadcast(group, {"type": "message", "from": "conn", "text": text},
+                                                   self.cfg.broadcast_timeout)
+            await event.reply(i18n.t(
+                "ConnHub.broadcast_done",
+                total=result.total,
+                sent=len(result.sent),
+                failed=len(result.failed),
+            ))
+
+        @command("conn close", master=True, help="关闭连接", args="<cid:str>")
+        async def conn_close_handler(event, cid: str):
+            try:
+                await self._service.close(cid, force=self.cfg.allow_force_close)
+            except Exception as e:
+                await event.reply(self._conn_error_text(e, cid))
+                return
+            await event.reply(i18n.t("ConnHub.close_done", id=cid))
+
+    async def _reply_card(self, event, html_fn, fallback_text: str):
+        if self.cfg.render_card:
+            png = await self._viz.render(html_fn(), theme=self.cfg.theme)
+            if png is not None:
+                try:
+                    await event.reply(png, method="Image")
+                    return
+                except Exception as e:
+                    self.logger.warning(f"图片回复失败，降级文本: {e}")
+        await event.reply(fallback_text)
+
+    def _conn_error_text(self, error: Exception, cid: str) -> str:
+        from ErisPulse import ConnectionNotFoundError, ConnectionPermissionError
+
+        if isinstance(error, ConnectionNotFoundError):
+            return i18n.t("ConnHub.close_not_found", id=cid)
+        if isinstance(error, ConnectionPermissionError):
+            owner = getattr(error, "owner", "") or ""
+            return i18n.t("ConnHub.close_forbidden", id=cid, owner=owner)
+        return f"{type(error).__name__}: {error}"
+
+    def _register_routes(self):
+        @router.get("/api/connections")
+        async def api_connections():
+            return respond(self._service.list_dicts())
+
+        @router.get("/api/stats")
+        async def api_stats():
+            return respond(self._service.stats())
+
+        @router.post("/api/broadcast")
+        async def api_broadcast(request):
+            try:
+                body = await request.json()
+            except Exception:
+                return respond({"error": "invalid_json"}, status_code=400)
+            data = body.get("data") if isinstance(body, dict) else None
+            if data is None:
+                return respond({"error": "data_required"}, status_code=400)
+            group = body.get("group") or None
+            try:
+                timeout = float(body.get("timeout", self.cfg.broadcast_timeout))
+            except (TypeError, ValueError):
+                timeout = self.cfg.broadcast_timeout
+            result = await self._service.broadcast(group, data, timeout)
+            return respond({
+                "total": result.total,
+                "sent": result.sent,
+                "failed": {cid: str(exc) for cid, exc in result.failed.items()},
+                "excluded": result.excluded,
+                "ok": result.ok,
+            })
+
+        @router.post("/api/close")
+        async def api_close(request):
+            try:
+                body = await request.json()
+            except Exception:
+                return respond({"error": "invalid_json"}, status_code=400)
+            cid = body.get("id") if isinstance(body, dict) else None
+            if not cid:
+                return respond({"error": "id_required"}, status_code=400)
+            force = bool(body.get("force")) and self.cfg.allow_force_close
+            try:
+                await self._service.close(cid, force=force)
+            except Exception as e:
+                from ErisPulse import ConnectionNotFoundError, ConnectionPermissionError
+
+                if isinstance(e, ConnectionNotFoundError):
+                    return respond({"error": "not_found", "id": cid}, status_code=404)
+                if isinstance(e, ConnectionPermissionError):
+                    return respond({"error": "permission_denied", "id": cid}, status_code=403)
+                return respond({"error": str(e)}, status_code=500)
+            return respond({"closed": cid})
+
+        @router.sse("/events")
+        async def event_stream(sse):
+            sse.join_group("connhub:watchers")
+            try:
+                await sse.send(self._service.snapshot_payload(), event="snapshot")
+            except Exception:
+                return
+            while True:
+                await asyncio.sleep(60)
+
+        if self.cfg.panel_enabled:
+            @router.get("/panel")
+            async def panel():
+                return PANEL_HTML, 200, {"Content-Type": "text/html; charset=utf-8"}
+
+            router.register_home_entry(
+                name={"i18n": "ConnHub.panel_title", "default": "ConnHub 连接面板"},
+                url="/connhub/panel",
+                icon_svg='<svg width="18" height="18" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.8"><circle cx="5" cy="12" r="2.5"/><circle cx="19" cy="6" r="2.5"/><circle cx="19" cy="18" r="2.5"/><path d="M7.5 12h4M13.5 10.8 16.5 7.6M13.5 13.2l3 3.2"/></svg>',
+            )

erispulse_connhub-0.1.0/ConnHub/I18n.py

@@ -0,0 +1,189 @@
+from ErisPulse.Core.Bases import BaseI18n, I18nKey
+
+
+class ConnHubI18n(BaseI18n):
+
+    enabled: I18nKey = I18nKey(
+        default="Enable module",
+        zh_CN="是否启用模块",
+        zh_TW="是否啟用模組",
+        en="Enable module",
+        ja="モジュールを有効化",
+        ru="Включить модуль",
+    )
+    api_enabled: I18nKey = I18nKey(
+        default="Enable HTTP API and SSE event stream",
+        zh_CN="启用 HTTP API 与 SSE 事件流",
+        zh_TW="啟用 HTTP API 與 SSE 事件流",
+        en="Enable HTTP API and SSE event stream",
+        ja="HTTP API と SSE イベントストリームを有効化",
+        ru="Включить HTTP API и поток событий SSE",
+    )
+    panel_enabled: I18nKey = I18nKey(
+        default="Enable built-in web panel",
+        zh_CN="启用内置连接面板网页",
+        zh_TW="啟用內建連線面板網頁",
+        en="Enable built-in web panel",
+        ja="内蔵ウェブパネルを有効化",
+        ru="Включить встроенную веб-панель",
+    )
+    allow_force_close: I18nKey = I18nKey(
+        default="Allow closing connections owned by other modules (skip ownership check)",
+        zh_CN="允许关闭其他模块归属的连接（跳过归属校验）",
+        zh_TW="允許關閉其他模組歸屬的連線（跳過歸屬校驗）",
+        en="Allow closing connections owned by other modules (skip ownership check)",
+        ja="他モジュール所有の接続を閉じることを許可（所有権チェックを省略）",
+        ru="Разрешить закрытие соединений других модулей (без проверки владельца)",
+    )
+    snapshot_interval_secs: I18nKey = I18nKey(
+        default="Snapshot push interval in seconds (0 = off)",
+        zh_CN="向面板推送全量快照的间隔秒数（0 关闭）",
+        zh_TW="向面板推送全量快照的間隔秒數（0 關閉）",
+        en="Snapshot push interval in seconds (0 = off)",
+        ja="スナップショット推送間隔（秒）（0 で無効）",
+        ru="Интервал отправки снапшотов в секундах (0 = выкл.)",
+    )
+    broadcast_timeout: I18nKey = I18nKey(
+        default="Per-connection send timeout for broadcast (seconds)",
+        zh_CN="广播时单条连接的发送超时秒数",
+        zh_TW="廣播時單條連線的傳送超時秒數",
+        en="Per-connection send timeout for broadcast (seconds)",
+        ja="ブロードキャストの接続ごとの送信タイムアウト（秒）",
+        ru="Таймаут отправки на одно соединение при рассылке (сек.)",
+    )
+    top_max: I18nKey = I18nKey(
+        default="Max connections shown in one list",
+        zh_CN="连接列表单次展示的最大条数",
+        zh_TW="連線列表單次展示的最大條數",
+        en="Max connections shown in one list",
+        ja="リスト1回の最大表示件数",
+        ru="Максимум соединений в одном списке",
+    )
+    render_card: I18nKey = I18nKey(
+        default="Render command output as image cards via Takumi (fallback to text)",
+        zh_CN="命令输出用 Takumi 渲染为卡片（不可用时降级文本）",
+        zh_TW="命令輸出用 Takumi 渲染為卡片（不可用時降級文本）",
+        en="Render command output as image cards via Takumi (fallback to text)",
+        ja="コマンド出力を Takumi でカード画像化（不可時はテキスト）",
+        ru="Рендер вывода команд в карточки через Takumi (иначе текст)",
+    )
+    theme: I18nKey = I18nKey(
+        default="Card color theme (auto = light/dark by time)",
+        zh_CN="卡片配色 (auto=按时间自动切深浅色)",
+        zh_TW="卡片配色 (auto=按時間自動切深淺色)",
+        en="Card color theme (auto = light/dark by time)",
+        ja="カード配色（auto=時間で自動切替）",
+        ru="Тема карточек (auto = светлая/тёмная по времени)",
+    )
+    module_loaded: I18nKey = I18nKey(
+        default="ConnHub loaded: {event}",
+        zh_CN="连接中心已加载: {event}",
+        zh_TW="連線中心已載入: {event}",
+        en="ConnHub loaded: {event}",
+        ja="ConnHub を読み込みました: {event}",
+        ru="ConnHub загружен: {event}",
+    )
+    module_unloaded: I18nKey = I18nKey(
+        default="ConnHub unloaded: {event}",
+        zh_CN="连接中心已卸载: {event}",
+        zh_TW="連線中心已卸載: {event}",
+        en="ConnHub unloaded: {event}",
+        ja="ConnHub を解除しました: {event}",
+        ru="ConnHub выгружен: {event}",
+    )
+    no_connections: I18nKey = I18nKey(
+        default="No connections registered",
+        zh_CN="当前没有登记中的连接",
+        zh_TW="當前沒有登記中的連線",
+        en="No connections registered",
+        ja="登録中の接続はありません",
+        ru="Нет зарегистрированных соединений",
+    )
+    list_header: I18nKey = I18nKey(
+        default="{count} connection(s):",
+        zh_CN="共 {count} 条连接：",
+        zh_TW="共 {count} 條連線：",
+        en="{count} connection(s):",
+        ja="{count} 件の接続：",
+        ru="Соединений: {count}",
+    )
+    list_truncated: I18nKey = I18nKey(
+        default="...and {count} more",
+        zh_CN="…其余 {count} 条已省略",
+        zh_TW="…其餘 {count} 條已省略",
+        en="...and {count} more",
+        ja="…他 {count} 件を省略",
+        ru="…ещё {count}",
+    )
+    stats_header: I18nKey = I18nKey(
+        default="Connection stats (total {total}):",
+        zh_CN="连接统计（共 {total} 条）：",
+        zh_TW="連線統計（共 {total} 條）：",
+        en="Connection stats (total {total}):",
+        ja="接続統計（合計 {total}）：",
+        ru="Статистика соединений (всего {total}):",
+    )
+    broadcast_done: I18nKey = I18nKey(
+        default="Broadcast finished: target {total}, sent {sent}, failed {failed}",
+        zh_CN="广播完成：目标 {total} 条，成功 {sent}，失败 {failed}",
+        zh_TW="廣播完成：目標 {total} 條，成功 {sent}，失敗 {failed}",
+        en="Broadcast finished: target {total}, sent {sent}, failed {failed}",
+        ja="ブロードキャスト完了：対象 {total}、成功 {sent}、失敗 {failed}",
+        ru="Рассылка завершена: цель {total}, отправлено {sent}, ошибок {failed}",
+    )
+    close_done: I18nKey = I18nKey(
+        default="Connection closed: {id}",
+        zh_CN="连接已关闭: {id}",
+        zh_TW="連線已關閉: {id}",
+        en="Connection closed: {id}",
+        ja="接続を閉じました: {id}",
+        ru="Соединение закрыто: {id}",
+    )
+    close_not_found: I18nKey = I18nKey(
+        default="Connection not found: {id}",
+        zh_CN="连接不存在或已断开: {id}",
+        zh_TW="連線不存在或已斷開: {id}",
+        en="Connection not found: {id}",
+        ja="接続が見つかりません: {id}",
+        ru="Соединение не найдено: {id}",
+    )
+    close_forbidden: I18nKey = I18nKey(
+        default="Permission denied: connection {id} is owned by {owner}",
+        zh_CN="权限不足：连接 {id} 归属于 {owner}，可在配置中开启 allow_force_close",
+        zh_TW="權限不足：連線 {id} 歸屬於 {owner}，可在配置中開啟 allow_force_close",
+        en="Permission denied: connection {id} is owned by {owner}",
+        ja="権限がありません: 接続 {id} は {owner} の所有です",
+        ru="Доступ запрещён: соединение {id} принадлежит {owner}",
+    )
+    group_assigned: I18nKey = I18nKey(
+        default="Connection {id} joined group {group}",
+        zh_CN="连接 {id} 已加入分组 {group}",
+        zh_TW="連線 {id} 已加入分組 {group}",
+        en="Connection {id} joined group {group}",
+        ja="接続 {id} をグループ {group} に追加しました",
+        ru="Соединение {id} добавлено в группу {group}",
+    )
+    group_dismissed: I18nKey = I18nKey(
+        default="Connection {id} left group {group}",
+        zh_CN="连接 {id} 已移出分组 {group}",
+        zh_TW="連線 {id} 已移出分組 {group}",
+        en="Connection {id} left group {group}",
+        ja="接続 {id} をグループ {group} から外しました",
+        ru="Соединение {id} удалено из группы {group}",
+    )
+    panel_title: I18nKey = I18nKey(
+        default="ConnHub connections panel",
+        zh_CN="ConnHub 连接面板",
+        zh_TW="ConnHub 連線面板",
+        en="ConnHub connections panel",
+        ja="ConnHub 接続パネル",
+        ru="Панель соединений ConnHub",
+    )
+    invalid_kind: I18nKey = I18nKey(
+        default="Unknown connection kind: {kind} (server/client/sse)",
+        zh_CN="未知的连接种类: {kind}（可选 server/client/sse）",
+        zh_TW="未知的連線種類: {kind}（可選 server/client/sse）",
+        en="Unknown connection kind: {kind} (server/client/sse)",
+        ja="不明な接続種別: {kind}（server/client/sse）",
+        ru="Неизвестный тип соединения: {kind} (server/client/sse)",
+    )

erispulse_connhub-0.1.0/ConnHub/Panel.py

@@ -0,0 +1,85 @@
+PANEL_HTML = """<!DOCTYPE html>
+<html lang="zh-CN">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<title>ConnHub</title>
+<style>
+:root { color-scheme: dark; }
+* { box-sizing: border-box; }
+body { margin: 0; font-family: system-ui, "Segoe UI", sans-serif; background: #14161a; color: #d7dae0; }
+header { padding: 16px 24px; border-bottom: 1px solid #262a31; display: flex; align-items: baseline; gap: 12px; }
+h1 { font-size: 18px; margin: 0; }
+#live { font-size: 12px; color: #6f7783; }
+main { padding: 20px 24px; max-width: 1080px; margin: 0 auto; }
+.cards { display: grid; grid-template-columns: repeat(auto-fit, minmax(160px, 1fr)); gap: 12px; margin-bottom: 20px; }
+.card { background: #1b1f26; border: 1px solid #262a31; border-radius: 8px; padding: 12px 14px; }
+.card .label { font-size: 12px; color: #8b93a1; }
+.card .value { font-size: 22px; margin-top: 4px; }
+h2 { font-size: 14px; color: #8b93a1; margin: 20px 0 8px; font-weight: 600; }
+table { width: 100%; border-collapse: collapse; font-size: 13px; }
+th, td { text-align: left; padding: 7px 10px; border-bottom: 1px solid #262a31; white-space: nowrap; overflow: hidden; text-overflow: ellipsis; max-width: 320px; }
+th { color: #8b93a1; font-weight: 600; }
+#events { font-size: 12px; font-family: ui-monospace, Consolas, monospace; background: #1b1f26; border: 1px solid #262a31; border-radius: 8px; padding: 10px 12px; height: 180px; overflow-y: auto; }
+#events div { padding: 2px 0; border-bottom: 1px dashed #22262d; }
+.empty { color: #6f7783; font-size: 13px; }
+</style>
+</head>
+<body>
+<header><h1>ConnHub 连接面板</h1><span id="live">connecting...</span></header>
+<main>
+  <div class="cards" id="cards"></div>
+  <h2>连接列表</h2>
+  <table>
+    <thead><tr><th>ID</th><th>种类</th><th>命名空间</th><th>归属</th><th>分组</th></tr></thead>
+    <tbody id="rows"><tr><td colspan="5" class="empty">加载中...</td></tr></tbody>
+  </table>
+  <h2>事件流</h2>
+  <div id="events"></div>
+</main>
+<script>
+const fmt = (v) => v === undefined || v === null || v === "" ? "-" : v;
+function renderStats(stats) {
+  const cards = [["总计", stats.total], ["种类", Object.entries(stats.by_kind || {}).map(([k, v]) => k + ": " + v).join(" ") || "-"],
+                 ["累计登记", stats.registered_total], ["累计注销", stats.unregistered_total]];
+  document.getElementById("cards").innerHTML = cards.map(([l, v]) =>
+    '<div class="card"><div class="label">' + l + '</div><div class="value">' + fmt(v) + "</div></div>").join("");
+}
+function renderRows(conns) {
+  const rows = document.getElementById("rows");
+  if (!conns.length) { rows.innerHTML = '<tr><td colspan="5" class="empty">暂无连接</td></tr>'; return; }
+  rows.innerHTML = conns.map(c =>
+    "<tr><td>" + c.id + "</td><td>" + c.kind + "</td><td>" + fmt(c.namespace) + "</td><td>" + fmt(c.owner) +
+    "</td><td>" + (c.groups.length ? c.groups.join(", ") : "-") + "</td></tr>").join("");
+}
+async function refresh() {
+  try {
+    const res = await fetch("api/stats", {headers: {"Accept": "application/json"}});
+    if (res.ok) renderStats(await res.json());
+    const res2 = await fetch("api/connections", {headers: {"Accept": "application/json"}});
+    if (res2.ok) renderRows(await res2.json());
+  } catch (e) { document.getElementById("live").textContent = "fetch failed"; }
+}
+function logEvent(text) {
+  const box = document.getElementById("events");
+  const div = document.createElement("div");
+  const now = new Date().toLocaleTimeString();
+  div.textContent = "[" + now + "] " + text;
+  box.prepend(div);
+  while (box.childElementCount > 100) box.lastChild.remove();
+}
+refresh();
+setInterval(refresh, 5000);
+const es = new EventSource("events");
+es.onopen = () => { document.getElementById("live").textContent = "live"; };
+es.onerror = () => { document.getElementById("live").textContent = "reconnecting..."; };
+es.onmessage = (ev) => {
+  let data;
+  try { data = JSON.parse(ev.data); } catch (e) { return; }
+  if (data.type === "snapshot") { renderStats(data.stats); renderRows(data.connections); return; }
+  if (data.type === "connection") { logEvent(ev.data); refresh(); }
+};
+</script>
+</body>
+</html>
+"""