v5.0: Integrate hermes-web-ui (Vue 3 + Naive UI)

- Dockerfile: Add Node.js 23 + hermes-web-ui build step
- entry.py: Add /webui route serving Vue SPA with client-side routing fallback
- WebUI features: Chat interface, session management, model selector, logs, usage analytics
- Theme: Hermes orange (#ff6b35) primary color, high-contrast dark mode
- i18n: Default language set to Chinese (zh), hardcoded English strings fixed
- Static assets served with cache headers, SPA fallback for client-side routing

Dockerfile

@@ -1,8 +1,13 @@
 FROM python:3.12-slim
 
-# System deps
+# System deps (git + Node.js 23 + build tools for node-pty)
 RUN apt-get update && apt-get install -y --no-install-recommends \
-    git curl gnupg2 fontconfig \
+    git curl gnupg2 fontconfig make g++ \
+    && rm -rf /var/lib/apt/lists/*
+
+# Install Node.js 23
+RUN curl -fsSL https://deb.nodesource.com/setup_23.x | bash - \
+    && apt-get install -y --no-install-recommends nodejs \
     && rm -rf /var/lib/apt/lists/*
 
 WORKDIR /app
@@ -10,14 +15,14 @@ WORKDIR /app
 # Clone hermes-agent
 RUN git clone --depth 1 https://github.com/NousResearch/hermes-agent.git /app/hermes-agent
 
-# Build venv
+# Build Python venv
 RUN python3 -m venv /app/venv
-ENV PATH="/app/venv/bin:$PATH"
+ENV PATH="/app/venv/bin:/usr/local/bin:$PATH"
 RUN pip install --quiet --upgrade pip && \
     pip install --quiet psutil networkx && \
     pip install --quiet -e "/app/hermes-agent[feishu,mcp,cron,pty]" 2>&1 | tail -10
 
-# Chinese font (download Noto Sans SC Regular + Bold, ~16MB)
+# Chinese font (Noto Sans SC Regular + Bold, ~16MB)
 RUN mkdir -p /usr/share/fonts/truetype/noto && \
     curl -sL "https://github.com/googlefonts/noto-cjk/raw/main/Sans/SubsetOTF/SC/NotoSansSC-Regular.otf" \
     -o /usr/share/fonts/truetype/noto/NotoSansSC-Regular.otf && \
@@ -25,6 +30,19 @@ RUN mkdir -p /usr/share/fonts/truetype/noto && \
     -o /usr/share/fonts/truetype/noto/NotoSansSC-Bold.otf && \
     fc-cache -f
 
+# ── Build hermes-web-ui ──
+RUN git clone --depth 1 https://github.com/EKKOLearnAI/hermes-web-ui.git /tmp/hermes-web-ui && \
+    cd /tmp/hermes-web-ui && \
+    npm install --quiet 2>&1 | tail -5 && \
+    npm run build 2>&1 | tail -10 && \
+    cp -r dist/client/. /app/webui/ && \
+    cp dist/server/index.js /app/webui-server/ && \
+    rm -rf /tmp/hermes-web-ui && \
+    echo "WebUI build complete"
+
+# Cleanup build tools (save ~200MB)
+RUN apt-get purge -y --auto-remove make g++ && rm -rf /var/lib/apt/lists/*
+
 # Create hermes home
 RUN mkdir -p /root/.hermes/plugins/image_gen/pollinations
 
@@ -34,7 +52,6 @@ COPY SOUL.md /root/.hermes/SOUL.md
 COPY .env /root/.hermes/.env
 COPY entry.py /app/entry.py
 COPY dashboard.html /app/dashboard.html
-COPY deploy.html /app/deploy.html
 COPY plugins/pollinations/ /root/.hermes/plugins/image_gen/pollinations/
 COPY scripts/ /app/scripts/
 

entry.py

@@ -3,6 +3,8 @@
 
 Serves a real-time monitoring dashboard on port 7860 and runs the
 Hermes Gateway (Feishu WebSocket bot) in a background thread.
+
+v5.0+: Also serves hermes-web-ui (Vue SPA) at /webui
 """
 
 import json
@@ -21,6 +23,7 @@ from pathlib import Path
 from urllib.parse import urlparse, parse_qs
 from queue import Queue, Empty
 from io import BytesIO
+import mimetypes
 
 
 class ThreadingHTTPServer(ThreadingMixIn, HTTPServer):
@@ -37,7 +40,7 @@ LOG_FILE = os.path.join(LOG_DIR, "gateway.log")
 CONFIG_FILE = os.path.join(HERMES_HOME, "config.yaml")
 ENV_FILE = os.path.join(HERMES_HOME, ".env")
 DASHBOARD_HTML = "/app/dashboard.html"
-DEPLOY_HTML = "/app/deploy.html"
+WEBUI_DIR = "/app/webui"
 
 # ---------------------------------------------------------------------------
 # Logging
@@ -62,10 +65,10 @@ _log_tail_offset = 0
 # ---------------------------------------------------------------------------
 
 def _mask_key(key: str) -> str:
-    """Mask API key for display: sk-or-v1-abc...xyz → sk-or-v1-ab••••wxyz"""
+    """Mask API key for display: sk-or-v1-abc...xyz -> sk-or-v1-ab....wxyz"""
     if not key or len(key) < 10:
-        return "••••••••"
-    return key[:7] + "••••" + key[-4:]
+        return "........"
+    return key[:7] + "...." + key[-4:]
 
 
 def _load_env() -> dict[str, str]:
@@ -92,7 +95,6 @@ def _load_config() -> dict:
         with open(CONFIG_FILE) as f:
             return yaml.safe_load(f) or {}
     except ImportError:
-        # Fallback: simple flat parser (no nested support)
         cfg: dict = {}
         try:
             with open(CONFIG_FILE) as f:
@@ -113,7 +115,6 @@ def _load_config() -> dict:
 
 
 def _get_sessions_count() -> int:
-    """Count session files."""
     sessions_dir = os.path.join(HERMES_HOME, "sessions")
     if not os.path.isdir(sessions_dir):
         return 0
@@ -124,7 +125,6 @@ def _get_sessions_count() -> int:
 
 
 def _get_session_list() -> list[dict]:
-    """Get list of recent sessions."""
     sessions_dir = os.path.join(HERMES_HOME, "sessions")
     sessions = []
     if not os.path.isdir(sessions_dir):
@@ -150,14 +150,12 @@ def _get_session_list() -> list[dict]:
 
 
 # ---------------------------------------------------------------------------
-# Log tailer — reads log file and pushes to SSE subscribers
+# Log tailer
 # ---------------------------------------------------------------------------
 
 def _parse_log_line(line: str) -> dict | None:
-    """Parse a log line like: 2026-04-27 22:19:12 [INFO] ..."""
     m = re.match(r"^(\d{4}-\d{2}-\d{2}\s+\d{2}:\d{2}:\d{2})\s*\[?(INFO|WARN|WARNING|ERROR|DEBUG)\]?\s*(.*)", line)
     if not m:
-        # Try other format: [timestamp] [LEVEL] name: msg
         m = re.match(r"\[?(\d{4}-\d{2}-\d{2}\s+\d{2}:\d{2}:\d{2})\]?\s*\[?(INFO|WARN|WARNING|ERROR|DEBUG)\]?.*?:\s*(.*)", line)
     if not m:
         return None
@@ -170,7 +168,6 @@ def _parse_log_line(line: str) -> dict | None:
 
 
 def _log_tailer():
-    """Background thread: tails gateway log and pushes to subscribers."""
     global _log_tail_offset
     while True:
         try:
@@ -178,7 +175,6 @@ def _log_tailer():
                 time.sleep(2)
                 continue
             with open(LOG_FILE, "r", errors="replace") as f:
-                # Seek to where we left off
                 f.seek(_log_tail_offset)
                 new_lines = f.readlines()
                 _log_tail_offset = f.tell()
@@ -189,7 +185,6 @@ def _log_tailer():
                         if p:
                             parsed.append(p)
                     if parsed:
-                        # Push to all subscribers
                         dead = []
                         for q in _log_subscribers:
                             try:
@@ -205,17 +200,14 @@ def _log_tailer():
 
 
 # ---------------------------------------------------------------------------
-# Persistent storage setup
+# Persistent storage
 # ---------------------------------------------------------------------------
 
 def _ensure_persistent_storage():
-    """Create data dirs and symlinks."""
     for d in ("sessions", "memories", "uploads", "logs", "palace", "skills"):
         os.makedirs(os.path.join(DATA_DIR, d), exist_ok=True)
-
     hermes = Path(HERMES_HOME)
     hermes.mkdir(parents=True, exist_ok=True)
-
     for d in ("sessions", "memories", "uploads", "logs", "palace", "skills"):
         target = hermes / d
         if not target.exists():
@@ -223,20 +215,19 @@ def _ensure_persistent_storage():
                 target.symlink_to(os.path.join(DATA_DIR, d))
                 logger.info("Symlink: %s -> %s", d, os.path.join(DATA_DIR, d))
             except OSError:
-                # Symlink failed (maybe in Docker build), just copy the dir structure
                 target.mkdir(exist_ok=True)
                 logger.warning("Could not symlink %s, using local dir", d)
 
 
 # ---------------------------------------------------------------------------
-# HTTP Handler — Dashboard + API
+# HTTP Handler — Dashboard + WebUI + API
 # ---------------------------------------------------------------------------
 
 class DashboardHandler(BaseHTTPRequestHandler):
-    """Serves dashboard HTML and REST API endpoints."""
+    """Serves dashboard HTML, WebUI SPA, and REST API endpoints."""
 
     def log_message(self, fmt, *args):
-        pass  # silence request logs
+        pass
 
     def _send_json(self, data: dict, status=200):
         body = json.dumps(data, ensure_ascii=False).encode("utf-8")
@@ -259,37 +250,70 @@ class DashboardHandler(BaseHTTPRequestHandler):
         except FileNotFoundError:
             self.send_error(404)
 
+    def _send_file(self, filepath: str, content_type: str = None):
+        """Serve a static file from the webui directory."""
+        try:
+            with open(filepath, "rb") as f:
+                body = f.read()
+            if content_type is None:
+                content_type = mimetypes.guess_type(filepath)[0] or "application/octet-stream"
+            self.send_response(200)
+            self.send_header("Content-Type", content_type)
+            self.send_header("Content-Length", str(len(body)))
+            self.send_header("Cache-Control", "public, max-age=31536000")
+            self.end_headers()
+            self.wfile.write(body)
+        except FileNotFoundError:
+            self.send_error(404)
+
     def _read_body(self) -> bytes:
         length = int(self.headers.get("Content-Length", 0))
         return self.rfile.read(length) if length > 0 else b""
 
+    def _send_webui_html(self):
+        """Serve WebUI SPA index.html."""
+        index_path = os.path.join(WEBUI_DIR, "index.html")
+        if os.path.isfile(index_path):
+            self._send_html(index_path)
+        else:
+            self.send_error(404, "WebUI not built")
+
     # ── GET routes ──
 
     def do_GET(self):
         parsed = urlparse(self.path)
-
-        # Dashboard
-        if parsed.path in ("/", "/index.html"):
+        path = parsed.path
+
+        # WebUI SPA routes (serve static files or fall back to index.html)
+        if path == "/webui" or path == "/webui/":
+            return self._send_webui_html()
+
+        if path.startswith("/webui/"):
+            # Try serving static file first
+            static_path = os.path.join(WEBUI_DIR, path[len("/webui/"):])
+            if os.path.isfile(static_path):
+                return self._send_file(static_path)
+            # SPA fallback: serve index.html for client-side routing
+            return self._send_webui_html()
+
+        # Legacy dashboard
+        if path in ("/", "/index.html"):
             return self._send_html(DASHBOARD_HTML)
 
-        # Deploy overview
-        if parsed.path == "/deploy":
-            return self._send_html(DEPLOY_HTML)
-
         # SSE log stream
-        if parsed.path == "/api/logs/stream":
+        if path == "/api/logs/stream":
             return self._handle_sse()
 
         # Status
-        if parsed.path == "/api/status":
+        if path == "/api/status":
             return self._send_json(self._get_status())
 
         # Sessions
-        if parsed.path == "/api/sessions":
+        if path == "/api/sessions":
             return self._send_json(_get_session_list())
 
-        # Log history (REST, not SSE)
-        if parsed.path == "/api/logs":
+        # Log history
+        if path == "/api/logs":
             return self._send_json(self._get_log_history(parsed.query))
 
         self.send_error(404)
@@ -319,12 +343,10 @@ class DashboardHandler(BaseHTTPRequestHandler):
         is_running = False
         pid = "N/A"
 
-        # Check gateway process
         if _gateway_process and _gateway_process.poll() is None:
             is_running = True
             pid = str(_gateway_process.pid)
         else:
-            # Try to find hermes gateway process
             for proc in psutil.process_iter(["pid", "cmdline"]):
                 try:
                     cmdline = " ".join(proc.info.get("cmdline") or [])
@@ -346,7 +368,7 @@ class DashboardHandler(BaseHTTPRequestHandler):
             "model": model,
             "provider": provider,
             "fallback_model": fallback_model,
-            "platform": "飞书 Feishu",
+            "platform": "Feishu",
             "platform_mode": "WebSocket",
             "sessions": _get_sessions_count(),
             "messages": 0,
@@ -357,16 +379,14 @@ class DashboardHandler(BaseHTTPRequestHandler):
                 "FEISHU_APP_ID": env.get("FEISHU_APP_ID", ""),
                 "FEISHU_APP_SECRET": _mask_key(env.get("FEISHU_APP_SECRET", "")),
                 "terminal": cfg.get("terminal", {}).get("backend", "local") if isinstance(cfg.get("terminal"), dict) else "local",
-                "timezone": cfg.get("timezone", "北京时间 (UTC+8)"),
+                "timezone": cfg.get("timezone", "UTC+8"),
                 "max_turns": cfg.get("max_turns", "90"),
                 "memory": cfg.get("memory", {}).get("provider", "none") if isinstance(cfg.get("memory"), dict) else "none",
-                "mcp_servers": list(cfg.get("mcp_servers", {}).keys()) if isinstance(cfg.get("mcp_servers"), dict) else [],
                 "compress": cfg.get("compress", {}).get("enabled", False) if isinstance(cfg.get("compress"), dict) else False,
             },
         }
 
     def _handle_sse(self):
-        """Server-Sent Events for real-time log streaming."""
         self.send_response(200)
         self.send_header("Content-Type", "text/event-stream")
         self.send_header("Cache-Control", "no-cache")
@@ -378,13 +398,11 @@ class DashboardHandler(BaseHTTPRequestHandler):
         _log_subscribers.append(q)
 
         try:
-            # First, send recent log history
             history = self._get_log_history_inner(limit=100)
             if history:
                 self.wfile.write(f"data: {json.dumps(history, ensure_ascii=False)}\n\n".encode())
                 self.wfile.flush()
 
-            # Then stream new logs
             while True:
                 try:
                     lines = q.get(timeout=30)
@@ -392,7 +410,6 @@ class DashboardHandler(BaseHTTPRequestHandler):
                     self.wfile.write(payload.encode())
                     self.wfile.flush()
                 except Empty:
-                    # Send heartbeat
                     self.wfile.write(":heartbeat\n\n".encode())
                     self.wfile.flush()
         except (BrokenPipeError, ConnectionResetError, OSError):
@@ -407,7 +424,6 @@ class DashboardHandler(BaseHTTPRequestHandler):
         return self._get_log_history_inner(limit=limit)
 
     def _get_log_history_inner(self, limit: int = 100) -> list:
-        """Read last N lines from log file."""
         if not os.path.isfile(LOG_FILE):
             return []
         try:
@@ -423,7 +439,6 @@ class DashboardHandler(BaseHTTPRequestHandler):
             return []
 
     def _handle_restart(self):
-        """Restart the gateway process."""
         global _gateway_process, _gateway_start_time
         try:
             if _gateway_process and _gateway_process.poll() is None:
@@ -448,14 +463,12 @@ class DashboardHandler(BaseHTTPRequestHandler):
             self._send_json({"ok": False, "error": str(e)}, 500)
 
     def _handle_change_model(self):
-        """Change the LLM model in config.yaml."""
         try:
             body = json.loads(self._read_body())
             model = body.get("model", "")
             if not model:
                 return self._send_json({"ok": False, "error": "No model specified"})
 
-            # Update config.yaml
             config_path = CONFIG_FILE
             if not os.path.isfile(config_path):
                 return self._send_json({"ok": False, "error": "config.yaml not found"})
@@ -463,7 +476,6 @@ class DashboardHandler(BaseHTTPRequestHandler):
             with open(config_path, "r") as f:
                 content = f.read()
 
-            # Replace model line
             new_content = re.sub(
                 r"^model:.*$",
                 f"model: {model}",
@@ -484,26 +496,24 @@ class DashboardHandler(BaseHTTPRequestHandler):
 # ---------------------------------------------------------------------------
 
 def main():
-    logger.info("=== Hermes Agent — HuggingFace Space Entry ===")
+    logger.info("=== Hermes Agent v5.0 — HuggingFace Space Entry ===")
+    logger.info("WebUI available at /webui")
 
-    # Setup persistent storage
     _ensure_persistent_storage()
     logger.info("Persistent storage ready at %s", DATA_DIR)
 
-    # Start log tailer thread
     tailer = threading.Thread(target=_log_tailer, daemon=True)
     tailer.start()
     logger.info("Log tailer started")
 
-    # Start Hermes Gateway in subprocess (not thread, for isolation)
     global _gateway_process, _gateway_start_time
     _gateway_start_time = time.time()
     env = os.environ.copy()
     env["HERMES_ACCEPT_HOOKS"] = "1"
-    env["PYTHONUNBUFFERED"] = "1"  # 关键：禁用输出缓冲，日志实时写入文件
+    env["PYTHONUNBUFFERED"] = "1"
 
     os.makedirs(LOG_DIR, exist_ok=True)
-    log_fh = open(LOG_FILE, "a", buffering=1)  # 行缓冲
+    log_fh = open(LOG_FILE, "a", buffering=1)
 
     _gateway_process = subprocess.Popen(
         [sys.executable, "-u", "-m", "hermes_cli.main", "gateway", "run", "-v"],
@@ -514,9 +524,11 @@ def main():
     )
     logger.info("Gateway started (PID: %d)", _gateway_process.pid)
 
-    # Start dashboard HTTP server
     server = ThreadingHTTPServer(("0.0.0.0", 7860), DashboardHandler)
     logger.info("Dashboard listening on :7860")
+    logger.info("Access URLs:")
+    logger.info("  Dashboard (old): https://jackken-hermes-bot.hf.space/")
+    logger.info("  WebUI (new):      https://jackken-hermes-bot.hf.space/webui")
     server.serve_forever()