feat: add disable web root

Author: zijiren233

README.md

@@ -141,6 +141,7 @@ docker-compose up -d
 ```bash
 LISTEN=:3000                    # Server listen address
 ADMIN_KEY=your-admin-key        # Admin API key
+DISABLE_WEB_ROOT=true           # Redirect only `/` to GitHub, keep other web routes available
 ```
 
 #### **Database Configuration**

README.zh.md

@@ -142,6 +142,7 @@ docker-compose up -d
 ```bash
 LISTEN=:3000                    # 服务器监听地址
 ADMIN_KEY=your-admin-key        # 管理员 API 密钥
+DISABLE_WEB_ROOT=true           # 仅将 `/` 重定向到 GitHub，其他 Web 路径保持可访问
 ```
 
 #### **数据库配置**

core/common/config/env.go

@@ -14,6 +14,7 @@ var (
 	AdminKey             string
 	WebPath              string
 	DisableWeb           bool
+	DisableWebRoot       bool
 	FfmpegEnabled        bool
 	InternalToken        string
 	DisableModelConfig   bool
@@ -34,6 +35,7 @@ func ReloadEnv() {
 	AdminKey = os.Getenv("ADMIN_KEY")
 	WebPath = os.Getenv("WEB_PATH")
 	DisableWeb = env.Bool("DISABLE_WEB", false)
+	DisableWebRoot = env.Bool("DISABLE_WEB_ROOT", false)
 	FfmpegEnabled = env.Bool("FFMPEG_ENABLED", false)
 	InternalToken = os.Getenv("INTERNAL_TOKEN")
 	DisableModelConfig = env.Bool("DISABLE_MODEL_CONFIG", false)

core/relay/utils/utils_test.go

@@ -4,9 +4,11 @@ import (
 	"bytes"
 	"context"
 	"encoding/json"
+	"errors"
 	"io"
 	"net/http"
 	"net/http/httptest"
+	"net/url"
 	"testing"
 	"time"
 
@@ -74,6 +76,43 @@ func TestDoRequest(t *testing.T) {
 	})
 }
 
+func TestDoRequestResponseHeaderTimeout(t *testing.T) {
+	convey.Convey("DoRequest should timeout while awaiting response headers", t, func() {
+		ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+			time.Sleep(1500 * time.Millisecond)
+			w.WriteHeader(http.StatusOK)
+			_, _ = w.Write([]byte("ok"))
+		}))
+		defer ts.Close()
+
+		req, _ := http.NewRequestWithContext(context.Background(), http.MethodGet, ts.URL, nil)
+		start := time.Now()
+
+		resp, err := utils.DoRequest(req, time.Second)
+		if resp != nil {
+			defer resp.Body.Close()
+		}
+
+		elapsed := time.Since(start)
+
+		convey.So(resp, convey.ShouldBeNil)
+		convey.So(err, convey.ShouldNotBeNil)
+
+		var urlErr *url.Error
+		convey.So(errors.As(err, &urlErr), convey.ShouldBeTrue)
+		convey.So(errors.Is(err, context.DeadlineExceeded), convey.ShouldBeTrue)
+		convey.So(urlErr.Timeout(), convey.ShouldBeTrue)
+		convey.So(
+			urlErr.Err.Error(),
+			convey.ShouldEqual,
+			"net/http: timeout awaiting response headers",
+		)
+
+		convey.So(elapsed >= time.Second, convey.ShouldBeTrue)
+		convey.So(elapsed < 1400*time.Millisecond, convey.ShouldBeTrue)
+	})
+}
+
 func TestLoadHTTPClientReuse(t *testing.T) {
 	convey.Convey("LoadHTTPClient reuse", t, func() {
 		client1, err := utils.LoadHTTPClientE(time.Second, "")

core/router/static.go

@@ -16,6 +16,11 @@ import (
 	"github.com/sirupsen/logrus"
 )
 
+const (
+	githubProjectURL              = "https://github.com/labring/aiproxy"
+	githubProjectInitialCountdown = 15
+)
+
 func SetStaticFileRouter(router *gin.Engine) {
 	router.SetHTMLTemplate(
 		template.Must(
@@ -24,12 +29,7 @@ func SetStaticFileRouter(router *gin.Engine) {
 	)
 
 	if config.DisableWeb {
-		router.GET("/", func(ctx *gin.Context) {
-			ctx.HTML(http.StatusOK, "index.tmpl", gin.H{
-				"URL":               "https://github.com/labring/aiproxy",
-				"INITIAL_COUNTDOWN": 15,
-			})
-		})
+		router.GET("/", renderWebRootRedirectPage)
 
 		return
 	}
@@ -45,6 +45,8 @@ func SetStaticFileRouter(router *gin.Engine) {
 			panic(err)
 		}
 
+		registerWebRootRedirect(router)
+
 		fs := http.FS(public.Public)
 		router.NoRoute(newIndexNoRouteHandler(fs))
 	} else {
@@ -65,10 +67,27 @@ func SetStaticFileRouter(router *gin.Engine) {
 			panic(err)
 		}
 
+		registerWebRootRedirect(router)
 		router.NoRoute(newDynamicNoRouteHandler(http.Dir(absPath)))
 	}
 }
 
+func registerWebRootRedirect(router *gin.Engine) {
+	if !config.DisableWebRoot {
+		return
+	}
+
+	router.GET("/", renderWebRootRedirectPage)
+	router.HEAD("/", renderWebRootRedirectPage)
+}
+
+func renderWebRootRedirectPage(ctx *gin.Context) {
+	ctx.HTML(http.StatusOK, "index.tmpl", gin.H{
+		"URL":               githubProjectURL,
+		"INITIAL_COUNTDOWN": githubProjectInitialCountdown,
+	})
+}
+
 func checkNoRouteNotFound(req *http.Request) bool {
 	if req.Method != http.MethodGet &&
 		req.Method != http.MethodHead {

core/router/static_test.go

@@ -0,0 +1,158 @@
+package router_test
+
+import (
+	"context"
+	"net/http"
+	"net/http/httptest"
+	"os"
+	"path/filepath"
+	"testing"
+
+	"github.com/gin-gonic/gin"
+	"github.com/labring/aiproxy/core/common/config"
+	corerouter "github.com/labring/aiproxy/core/router"
+	"github.com/smartystreets/goconvey/convey"
+)
+
+const testGitHubProjectURL = "https://github.com/labring/aiproxy"
+
+func TestSetStaticFileRouter_DisableWebRoot(t *testing.T) {
+	convey.Convey("SetStaticFileRouter with DISABLE_WEB_ROOT", t, func() {
+		webPath := writeTestWebFiles(t)
+		router := newTestStaticRouter(t, webPath, false, true)
+
+		convey.Convey("should redirect root path to github", func() {
+			recorder := httptest.NewRecorder()
+			req := httptest.NewRequestWithContext(context.Background(), http.MethodGet, "/", nil)
+
+			router.ServeHTTP(recorder, req)
+
+			convey.So(recorder.Code, convey.ShouldEqual, http.StatusOK)
+			convey.So(recorder.Body.String(), convey.ShouldContainSubstring, testGitHubProjectURL)
+			convey.So(
+				recorder.Body.String(),
+				convey.ShouldContainSubstring,
+				"id=\"countdown\">15</div>",
+			)
+		})
+
+		convey.Convey("should keep static assets accessible", func() {
+			recorder := httptest.NewRecorder()
+			req := httptest.NewRequestWithContext(
+				context.Background(),
+				http.MethodGet,
+				"/assets/app.js",
+				nil,
+			)
+
+			router.ServeHTTP(recorder, req)
+
+			convey.So(recorder.Code, convey.ShouldEqual, http.StatusOK)
+			convey.So(recorder.Body.String(), convey.ShouldContainSubstring, "console.log('ok');")
+		})
+
+		convey.Convey("should keep SPA fallback accessible", func() {
+			recorder := httptest.NewRecorder()
+			req := httptest.NewRequestWithContext(
+				context.Background(),
+				http.MethodGet,
+				"/dashboard",
+				nil,
+			)
+
+			router.ServeHTTP(recorder, req)
+
+			convey.So(recorder.Code, convey.ShouldEqual, http.StatusOK)
+			convey.So(recorder.Body.String(), convey.ShouldContainSubstring, "test-spa")
+		})
+	})
+}
+
+func TestSetStaticFileRouter_DisableWeb(t *testing.T) {
+	convey.Convey("SetStaticFileRouter with DISABLE_WEB", t, func() {
+		webPath := writeTestWebFiles(t)
+		router := newTestStaticRouter(t, webPath, true, false)
+
+		convey.Convey("should serve the github redirect page on root", func() {
+			recorder := httptest.NewRecorder()
+			req := httptest.NewRequestWithContext(context.Background(), http.MethodGet, "/", nil)
+
+			router.ServeHTTP(recorder, req)
+
+			convey.So(recorder.Code, convey.ShouldEqual, http.StatusOK)
+			convey.So(recorder.Body.String(), convey.ShouldContainSubstring, testGitHubProjectURL)
+		})
+
+		convey.Convey("should not expose static assets", func() {
+			recorder := httptest.NewRecorder()
+			req := httptest.NewRequestWithContext(
+				context.Background(),
+				http.MethodGet,
+				"/assets/app.js",
+				nil,
+			)
+
+			router.ServeHTTP(recorder, req)
+
+			convey.So(recorder.Code, convey.ShouldEqual, http.StatusNotFound)
+		})
+	})
+}
+
+func newTestStaticRouter(
+	t *testing.T,
+	webPath string,
+	disableWeb, disableWebRoot bool,
+) *gin.Engine {
+	t.Helper()
+
+	gin.SetMode(gin.TestMode)
+
+	oldWebPath := config.WebPath
+	oldDisableWeb := config.DisableWeb
+	oldDisableWebRoot := config.DisableWebRoot
+
+	t.Cleanup(func() {
+		config.WebPath = oldWebPath
+		config.DisableWeb = oldDisableWeb
+		config.DisableWebRoot = oldDisableWebRoot
+	})
+
+	config.WebPath = webPath
+	config.DisableWeb = disableWeb
+	config.DisableWebRoot = disableWebRoot
+
+	router := gin.New()
+	corerouter.SetStaticFileRouter(router)
+
+	return router
+}
+
+func writeTestWebFiles(t *testing.T) string {
+	t.Helper()
+
+	webPath := t.TempDir()
+	assetsPath := filepath.Join(webPath, "assets")
+
+	if err := os.MkdirAll(assetsPath, 0o755); err != nil {
+		t.Fatalf("mkdir assets: %v", err)
+	}
+
+	if err := os.WriteFile(
+		filepath.Join(webPath, "index.html"),
+		[]byte("<!doctype html><html><body>test-spa</body></html>"),
+		0o600,
+	); err != nil {
+		t.Fatalf("write index.html: %v", err)
+	}
+
+	if err := os.WriteFile(
+		filepath.Join(assetsPath, "app.js"),
+		[]byte("console.log('ok');"),
+		0o600,
+	); err != nil {
+		t.Fatalf("write app.js: %v", err)
+	}
+
+	return webPath
+}