feat: add HuggingChat support (#477)

* add chat ui to dashboard and docker compose & refactor dashboard/backend/

Signed-off-by: JaredforReal <[email protected]>

* try fix network error

Signed-off-by: JaredforReal <[email protected]>

* more

---------

Signed-off-by: JaredforReal <[email protected]>
Co-authored-by: bitliu <[email protected]>

Author: JaredforReal

dashboard/backend/config/config.go

@@ -0,0 +1,75 @@
+package config
+
+import (
+	"flag"
+	"os"
+	"path/filepath"
+)
+
+// Config holds all application configuration
+type Config struct {
+	Port          string
+	StaticDir     string
+	ConfigFile    string
+	AbsConfigPath string
+	ConfigDir     string
+
+	// Upstream targets
+	GrafanaURL    string
+	PrometheusURL string
+	RouterAPIURL  string
+	RouterMetrics string
+	OpenWebUIURL  string
+	ChatUIURL     string
+	JaegerURL     string
+}
+
+// env returns the env var or default
+func env(key, def string) string {
+	if v := os.Getenv(key); v != "" {
+		return v
+	}
+	return def
+}
+
+// LoadConfig loads configuration from flags and environment variables
+func LoadConfig() (*Config, error) {
+	cfg := &Config{}
+
+	// Flags/env for configuration
+	port := flag.String("port", env("DASHBOARD_PORT", "8700"), "dashboard port")
+	staticDir := flag.String("static", env("DASHBOARD_STATIC_DIR", "../frontend"), "static assets directory")
+	configFile := flag.String("config", env("ROUTER_CONFIG_PATH", "../../config/config.yaml"), "path to config.yaml")
+
+	// Upstream targets
+	grafanaURL := flag.String("grafana", env("TARGET_GRAFANA_URL", ""), "Grafana base URL")
+	promURL := flag.String("prometheus", env("TARGET_PROMETHEUS_URL", ""), "Prometheus base URL")
+	routerAPI := flag.String("router_api", env("TARGET_ROUTER_API_URL", "http://localhost:8080"), "Router API base URL")
+	routerMetrics := flag.String("router_metrics", env("TARGET_ROUTER_METRICS_URL", "http://localhost:9190/metrics"), "Router metrics URL")
+	openwebuiURL := flag.String("openwebui", env("TARGET_OPENWEBUI_URL", ""), "Open WebUI base URL")
+	chatuiURL := flag.String("chatui", env("TARGET_CHATUI_URL", ""), "Hugging Face Chat UI base URL")
+	jaegerURL := flag.String("jaeger", env("TARGET_JAEGER_URL", ""), "Jaeger base URL")
+
+	flag.Parse()
+
+	cfg.Port = *port
+	cfg.StaticDir = *staticDir
+	cfg.ConfigFile = *configFile
+	cfg.GrafanaURL = *grafanaURL
+	cfg.PrometheusURL = *promURL
+	cfg.RouterAPIURL = *routerAPI
+	cfg.RouterMetrics = *routerMetrics
+	cfg.OpenWebUIURL = *openwebuiURL
+	cfg.ChatUIURL = *chatuiURL
+	cfg.JaegerURL = *jaegerURL
+
+	// Resolve config file path to absolute path
+	absConfigPath, err := filepath.Abs(cfg.ConfigFile)
+	if err != nil {
+		return nil, err
+	}
+	cfg.AbsConfigPath = absConfigPath
+	cfg.ConfigDir = filepath.Dir(absConfigPath)
+
+	return cfg, nil
+}

dashboard/backend/handlers/config.go

@@ -0,0 +1,85 @@
+package handlers
+
+import (
+	"encoding/json"
+	"fmt"
+	"log"
+	"net/http"
+	"os"
+
+	yaml "gopkg.in/yaml.v3"
+)
+
+// ConfigHandler reads and serves the config.yaml file as JSON
+func ConfigHandler(configPath string) http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		// Only allow GET requests
+		if r.Method != http.MethodGet {
+			http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)
+			return
+		}
+
+		// Read the config file
+		data, err := os.ReadFile(configPath)
+		if err != nil {
+			log.Printf("Error reading config file: %v", err)
+			http.Error(w, fmt.Sprintf("Failed to read config file: %v", err), http.StatusInternalServerError)
+			return
+		}
+
+		// Parse YAML
+		var config interface{}
+		if err := yaml.Unmarshal(data, &config); err != nil {
+			log.Printf("Error parsing config YAML: %v", err)
+			http.Error(w, fmt.Sprintf("Failed to parse config: %v", err), http.StatusInternalServerError)
+			return
+		}
+
+		// Convert to JSON and send response
+		w.Header().Set("Content-Type", "application/json")
+		if err := json.NewEncoder(w).Encode(config); err != nil {
+			log.Printf("Error encoding config to JSON: %v", err)
+			http.Error(w, fmt.Sprintf("Failed to encode config: %v", err), http.StatusInternalServerError)
+			return
+		}
+	}
+}
+
+// UpdateConfigHandler updates the config.yaml file
+func UpdateConfigHandler(configPath string) http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		// Only allow POST/PUT requests
+		if r.Method != http.MethodPost && r.Method != http.MethodPut {
+			http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)
+			return
+		}
+
+		// Read the request body
+		var configData map[string]interface{}
+		if err := json.NewDecoder(r.Body).Decode(&configData); err != nil {
+			log.Printf("Error decoding request body: %v", err)
+			http.Error(w, fmt.Sprintf("Invalid request body: %v", err), http.StatusBadRequest)
+			return
+		}
+
+		// Convert to YAML
+		yamlData, err := yaml.Marshal(configData)
+		if err != nil {
+			log.Printf("Error marshaling config to YAML: %v", err)
+			http.Error(w, fmt.Sprintf("Failed to convert config to YAML: %v", err), http.StatusInternalServerError)
+			return
+		}
+
+		// Write to file
+		if err := os.WriteFile(configPath, yamlData, 0644); err != nil {
+			log.Printf("Error writing config file: %v", err)
+			http.Error(w, fmt.Sprintf("Failed to write config file: %v", err), http.StatusInternalServerError)
+			return
+		}
+
+		log.Printf("Configuration updated successfully")
+		w.Header().Set("Content-Type", "application/json")
+		w.WriteHeader(http.StatusOK)
+		json.NewEncoder(w).Encode(map[string]string{"status": "success", "message": "Configuration updated successfully"})
+	}
+}

dashboard/backend/handlers/health.go

@@ -0,0 +1,12 @@
+package handlers
+
+import (
+	"net/http"
+)
+
+// HealthCheck handles health check endpoint
+func HealthCheck(w http.ResponseWriter, r *http.Request) {
+	w.Header().Set("Content-Type", "application/json")
+	w.WriteHeader(http.StatusOK)
+	w.Write([]byte(`{"status":"healthy","service":"semantic-router-dashboard"}`))
+}

dashboard/backend/handlers/static.go

@@ -0,0 +1,61 @@
+package handlers
+
+import (
+	"net/http"
+	"os"
+	"path"
+	"strings"
+)
+
+// StaticFileServer serves static files and handles SPA routing
+func StaticFileServer(staticDir string) http.Handler {
+	fs := http.FileServer(http.Dir(staticDir))
+	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		// Never serve index.html for API or embedded proxy routes
+		// These should be handled by their respective handlers
+		p := r.URL.Path
+		// Never serve static files for proxy routes or ChatUI API endpoints
+		if strings.HasPrefix(p, "/api/") || strings.HasPrefix(p, "/embedded/") ||
+			strings.HasPrefix(p, "/metrics/") || strings.HasPrefix(p, "/public/") ||
+			strings.HasPrefix(p, "/avatar/") || strings.HasPrefix(p, "/_app/") ||
+			strings.HasPrefix(p, "/_next/") || strings.HasPrefix(p, "/chatui/") ||
+			p == "/conversation" || strings.HasPrefix(p, "/conversations") ||
+			strings.HasPrefix(p, "/settings") || p == "/login" || p == "/logout" ||
+			strings.HasPrefix(p, "/r/") {
+			// These paths should have been handled by other handlers
+			// If we reach here, it means the proxy failed or route not found
+			w.Header().Set("Content-Type", "application/json")
+			http.Error(w, `{"error":"Route not found","message":"This path should have been handled by a proxy"}`, http.StatusBadGateway)
+			return
+		}
+
+		full := path.Join(staticDir, path.Clean(p))
+
+		// Check if file exists
+		info, err := os.Stat(full)
+		if err == nil {
+			// File exists
+			if !info.IsDir() {
+				// It's a file, serve it
+				fs.ServeHTTP(w, r)
+				return
+			}
+			// It's a directory, try index.html
+			indexPath := path.Join(full, "index.html")
+			if _, err := os.Stat(indexPath); err == nil {
+				http.ServeFile(w, r, indexPath)
+				return
+			}
+		}
+
+		// File doesn't exist or is directory without index.html
+		// For SPA routing: serve index.html for routes without file extension
+		if !strings.Contains(path.Base(p), ".") {
+			http.ServeFile(w, r, path.Join(staticDir, "index.html"))
+			return
+		}
+
+		// Otherwise let the file server handle it (will return 404)
+		fs.ServeHTTP(w, r)
+	})
+}

dashboard/backend/handlers/tools.go

@@ -0,0 +1,48 @@
+package handlers
+
+import (
+	"encoding/json"
+	"fmt"
+	"log"
+	"net/http"
+	"os"
+	"path/filepath"
+)
+
+// ToolsDBHandler reads and serves the tools_db.json file
+func ToolsDBHandler(configDir string) http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		// Only allow GET requests
+		if r.Method != http.MethodGet {
+			http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)
+			return
+		}
+
+		// Construct the tools_db.json path
+		toolsDBPath := filepath.Join(configDir, "tools_db.json")
+
+		// Read the tools database file
+		data, err := os.ReadFile(toolsDBPath)
+		if err != nil {
+			log.Printf("Error reading tools_db.json: %v", err)
+			http.Error(w, fmt.Sprintf("Failed to read tools database: %v", err), http.StatusInternalServerError)
+			return
+		}
+
+		// Parse JSON to validate it
+		var tools interface{}
+		if err := json.Unmarshal(data, &tools); err != nil {
+			log.Printf("Error parsing tools_db.json: %v", err)
+			http.Error(w, fmt.Sprintf("Failed to parse tools database: %v", err), http.StatusInternalServerError)
+			return
+		}
+
+		// Send response
+		w.Header().Set("Content-Type", "application/json")
+		if err := json.NewEncoder(w).Encode(tools); err != nil {
+			log.Printf("Error encoding tools to JSON: %v", err)
+			http.Error(w, fmt.Sprintf("Failed to encode tools: %v", err), http.StatusInternalServerError)
+			return
+		}
+	}
+}