Implement asset routes

Author: yottahmd

Diff for: api/v1/api.gen.go

@@ -435,7 +435,6 @@ components:
     DAGDetailTab:
       type: string
       description: "Indicates which part of the DAG to retrieve"
-      default: status
       enum:
         - status
         - spec

Diff for: api/v1/api.yaml

@@ -26,18 +26,32 @@ import (
 )
 
 type Server struct {
-	api        *api.API
-	config     *config.Config
-	httpServer *http.Server
+	api         *api.API
+	config      *config.Config
+	httpServer  *http.Server
+	funcsConfig funcsConfig
 }
 
 func NewServer(
 	api *api.API,
 	cfg *config.Config,
 ) *Server {
+	var remoteNodes []string
+	for _, node := range cfg.Server.RemoteNodes {
+		remoteNodes = append(remoteNodes, node.Name)
+	}
 	return &Server{
 		api:    api,
 		config: cfg,
+		funcsConfig: funcsConfig{
+			NavbarColor:           cfg.UI.NavbarColor,
+			NavbarTitle:           cfg.UI.NavbarTitle,
+			BasePath:              cfg.Server.BasePath,
+			APIBasePath:           cfg.Server.APIBasePath,
+			TZ:                    cfg.Global.TZ,
+			MaxDashboardPageLimit: cfg.UI.MaxDashboardPageLimit,
+			RemoteNodes:           remoteNodes,
+		},
 	}
 }
 
@@ -57,12 +71,14 @@ func (srv *Server) Serve(ctx context.Context) error {
 	r.Use(httplog.RequestLogger(requestLogger))
 	r.Use(withRecoverer)
 	r.Use(cors.Handler(cors.Options{
-		AllowedOrigins:   []string{"*"},
+		AllowedOrigins:   []string{"*"}, // TODO: Update to specific origins
 		AllowedMethods:   []string{"GET", "POST", "PUT", "PATCH", "DELETE", "OPTIONS"},
 		AllowedHeaders:   []string{"*"},
 		AllowCredentials: true,
 	}))
 
+	srv.routes(ctx, r)
+
 	basePath := path.Join(srv.config.Server.BasePath, "api/v1")
 	if !strings.HasPrefix(basePath, "/") {
 		basePath = "/" + basePath
@@ -100,6 +116,27 @@ func (srv *Server) Serve(ctx context.Context) error {
 	return nil
 }
 
+func (srv *Server) routes(ctx context.Context, r *chi.Mux) {
+	// Always allow API routes to work
+	if srv.config.Server.Headless {
+		logger.Info(ctx, "Headless mode enabled: UI is disabled, but API remains active")
+
+		// Only register API routes, skip Web UI routes
+		return
+	}
+
+	// Serve assets (optional, remove if not needed)
+	r.Get("/assets/*", func(w http.ResponseWriter, r *http.Request) {
+		w.Header().Set("Cache-Control", "max-age=86400")
+		http.FileServer(http.FS(assetsFS)).ServeHTTP(w, r)
+	})
+
+	// Serve UI pages (disable when headless)
+	r.Get("/*", func(w http.ResponseWriter, _ *http.Request) {
+		srv.useTemplate(ctx, "index.gohtml", "index")(w, nil)
+	})
+}
+
 func (srv *Server) Shutdown(ctx context.Context) error {
 	if srv.httpServer != nil {
 		logger.Info(ctx, "Server is shutting down", "addr", srv.httpServer.Addr)

Diff for: internal/frontend/assets.go

@@ -0,0 +1,107 @@
+package frontend
+
+import (
+	"bytes"
+	"context"
+	"embed"
+	"io"
+	"net/http"
+	"path"
+	"path/filepath"
+	"strings"
+	"text/template"
+
+	_ "embed"
+
+	"github.com/dagu-org/dagu/internal/build"
+	"github.com/dagu-org/dagu/internal/logger"
+)
+
+//go:embed templates/* assets/*
+var assetsFS embed.FS
+
+// templatePath is the path to the templates directory.
+var templatePath = "templates/"
+
+func (srv *Server) useTemplate(ctx context.Context, layout string, name string) func(http.ResponseWriter, any) {
+	// Skip template rendering if headless
+	if srv.config.Server.Headless {
+		return func(w http.ResponseWriter, _ any) {
+			http.Error(w, "Web UI is disabled in headless mode", http.StatusForbidden)
+		}
+	}
+
+	files := append(baseTemplates(), filepath.Join(templatePath, layout))
+	tmpl, err := template.New(name).Funcs(
+		defaultFunctions(srv.funcsConfig)).ParseFS(assetsFS, files...,
+	)
+	if err != nil {
+		panic(err)
+	}
+
+	return func(w http.ResponseWriter, data any) {
+		var buf bytes.Buffer
+		if err := tmpl.ExecuteTemplate(&buf, "base", data); err != nil {
+			logger.Error(ctx, "Template execution failed", "err", err)
+			http.Error(w, err.Error(), http.StatusInternalServerError)
+			return
+		}
+		w.WriteHeader(http.StatusOK)
+		_, _ = io.Copy(w, &buf)
+	}
+}
+
+type funcsConfig struct {
+	NavbarColor           string
+	NavbarTitle           string
+	BasePath              string
+	APIBasePath           string
+	TZ                    string
+	MaxDashboardPageLimit int
+	RemoteNodes           []string
+}
+
+func defaultFunctions(cfg funcsConfig) template.FuncMap {
+	return template.FuncMap{
+		"defTitle": func(ip any) string {
+			v, ok := ip.(string)
+			if !ok || (ok && v == "") {
+				return ""
+			}
+			return v
+		},
+		"version": func() string {
+			return build.Version
+		},
+		"navbarColor": func() string {
+			return cfg.NavbarColor
+		},
+		"navbarTitle": func() string {
+			return cfg.NavbarTitle
+		},
+		"basePath": func() string {
+			return cfg.BasePath
+		},
+		"apiURL": func() string {
+			return path.Join(cfg.BasePath, cfg.APIBasePath)
+		},
+		"tz": func() string {
+			return cfg.TZ
+		},
+		"maxDashboardPageLimit": func() int {
+			return cfg.MaxDashboardPageLimit
+		},
+		"remoteNodes": func() string {
+			return strings.Join(cfg.RemoteNodes, ",")
+		},
+	}
+}
+
+func baseTemplates() []string {
+	var templateFiles = []string{"base.gohtml"}
+	ret := make([]string, 0, len(templateFiles))
+	for _, t := range templateFiles {
+		ret = append(ret, filepath.Join(templatePath, t))
+	}
+	return ret
+}