sdk添加登录

cmd/demo-login/main.go

+package main
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"fmt"
+	"io"
+	"net/http"
+	"time"
+
+	"git.x2erp.com/qdy/go-base/sdk/configure"
+)
+
+func main() {
+	fmt.Println("=== 演示登录功能测试 ===")
+
+	// 配置服务地址
+	configureURL := "http://localhost:8080"
+	svcCodeURL := "http://localhost:8020"
+
+	fmt.Printf("配置中心地址: %s\n", configureURL)
+	fmt.Printf("svc-code地址: %s\n", svcCodeURL)
+
+	// 测试凭证
+	userID := "test-user-001"
+	password := "password123"
+
+	fmt.Printf("\n使用测试用户: %s\n", userID)
+
+	// 1. 直接使用SDK登录配置中心
+	fmt.Println("\n--- 方法1: 直接使用SDK登录配置中心 ---")
+	token1, err := loginWithSDK(configureURL, userID, password)
+	if err != nil {
+		fmt.Printf("SDK登录失败: %v\n", err)
+	} else {
+		fmt.Printf("✅ SDK登录成功!\n")
+		fmt.Printf("Token (前100字符): %s...\n", token1[:min(100, len(token1))])
+		fmt.Printf("Token长度: %d 字符\n", len(token1))
+
+		// 验证token
+		if err := validateTokenWithSDK(configureURL, token1); err != nil {
+			fmt.Printf("Token验证失败: %v\n", err)
+		} else {
+			fmt.Printf("✅ Token验证通过\n")
+		}
+	}
+
+	// 2. 通过svc-code API登录
+	fmt.Println("\n--- 方法2: 通过svc-code API登录 ---")
+	token2, err := loginWithAPI(svcCodeURL, userID, password)
+	if err != nil {
+		fmt.Printf("API登录失败: %v\n", err)
+	} else {
+		fmt.Printf("✅ API登录成功!\n")
+		fmt.Printf("Token (前100字符): %s...\n", token2[:min(100, len(token2))])
+		fmt.Printf("Token长度: %d 字符\n", len(token2))
+
+		// 比较两个token是否相同
+		if token1 != "" && token2 != "" {
+			if token1 == token2 {
+				fmt.Printf("✅ 两个方法返回的Token相同\n")
+			} else {
+				fmt.Printf("⚠️  两个方法返回的Token不同（可能是不同的JWT有效期）\n")
+			}
+		}
+	}
+
+	// 3. 测试无效凭证
+	fmt.Println("\n--- 测试无效凭证 ---")
+	testInvalidCredentials(svcCodeURL)
+
+	fmt.Println("\n=== 测试完成 ===")
+}
+
+// loginWithSDK 使用SDK直接登录配置中心
+func loginWithSDK(configureURL, userID, password string) (string, error) {
+	// 创建SDK客户端
+	client, err := configure.NewBasicAuthClient(configureURL, "test", "test")
+	if err != nil {
+		return "", fmt.Errorf("创建SDK客户端失败: %w", err)
+	}
+
+	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
+	defer cancel()
+
+	req := &configure.UserLoginRequest{
+		UserID:   userID,
+		Password: password,
+	}
+
+	startTime := time.Now()
+	token, err := client.LoginUser(ctx, req)
+	elapsed := time.Since(startTime)
+
+	if err != nil {
+		return "", fmt.Errorf("登录失败: %w (耗时: %v)", err, elapsed)
+	}
+
+	fmt.Printf("登录耗时: %v\n", elapsed)
+	return token, nil
+}
+
+// validateTokenWithSDK 使用SDK验证token
+func validateTokenWithSDK(configureURL, token string) error {
+	// 使用token创建配置中心客户端
+	client, err := configure.NewTokenAuthClient(configureURL, token)
+	if err != nil {
+		return fmt.Errorf("创建Token客户端失败: %w", err)
+	}
+
+	fmt.Printf("Token客户端创建成功，BaseURL: %s\n", client.GetConfig().BaseURL)
+	return nil
+}
+
+// loginWithAPI 通过svc-code API登录
+func loginWithAPI(svcCodeURL, userID, password string) (string, error) {
+	client := &http.Client{
+		Timeout: 30 * time.Second,
+	}
+
+	loginURL := fmt.Sprintf("%s/api/auth/login", svcCodeURL)
+	loginData := map[string]string{
+		"user_id":  userID,
+		"password": password,
+	}
+
+	loginJSON, err := json.Marshal(loginData)
+	if err != nil {
+		return "", fmt.Errorf("JSON序列化失败: %w", err)
+	}
+
+	startTime := time.Now()
+	req, err := http.NewRequest("POST", loginURL, bytes.NewReader(loginJSON))
+	if err != nil {
+		return "", fmt.Errorf("创建HTTP请求失败: %w", err)
+	}
+	req.Header.Set("Content-Type", "application/json")
+
+	resp, err := client.Do(req)
+	if err != nil {
+		return "", fmt.Errorf("发送登录请求失败: %w", err)
+	}
+	defer resp.Body.Close()
+
+	elapsed := time.Since(startTime)
+	fmt.Printf("API调用耗时: %v\n", elapsed)
+
+	if resp.StatusCode != 200 {
+		body, _ := io.ReadAll(resp.Body)
+		return "", fmt.Errorf("API返回非200状态码: %d, 响应: %s", resp.StatusCode, string(body))
+	}
+
+	body, err := io.ReadAll(resp.Body)
+	if err != nil {
+		return "", fmt.Errorf("读取响应体失败: %w", err)
+	}
+
+	var result map[string]interface{}
+	if err := json.Unmarshal(body, &result); err != nil {
+		return "", fmt.Errorf("解析响应JSON失败: %w, 响应体: %s", err, string(body))
+	}
+
+	if !result["success"].(bool) {
+		return "", fmt.Errorf("登录失败: %v", result)
+	}
+
+	token, ok := result["data"].(string)
+	if !ok || token == "" {
+		return "", fmt.Errorf("响应中未找到有效token: %v", result)
+	}
+
+	return token, nil
+}
+
+// testInvalidCredentials 测试无效凭证
+func testInvalidCredentials(svcCodeURL string) {
+	client := &http.Client{
+		Timeout: 10 * time.Second,
+	}
+
+	loginURL := fmt.Sprintf("%s/api/auth/login", svcCodeURL)
+	invalidData := map[string]string{
+		"user_id":  "invalid-user",
+		"password": "wrong-password",
+	}
+
+	invalidJSON, _ := json.Marshal(invalidData)
+
+	resp, err := client.Post(loginURL, "application/json", bytes.NewReader(invalidJSON))
+	if err != nil {
+		fmt.Printf("无效凭证测试失败: %v\n", err)
+		return
+	}
+	defer resp.Body.Close()
+
+	body, _ := io.ReadAll(resp.Body)
+	var result map[string]interface{}
+	json.Unmarshal(body, &result)
+
+	if !result["success"].(bool) {
+		fmt.Printf("✅ 无效凭证登录失败（预期）: %s\n", result["message"])
+	} else {
+		fmt.Printf("❌ 无效凭证登录不应该成功\n")
+	}
+}
+
+// min 返回两个整数的最小值
+func min(a, b int) int {
+	if a < b {
+		return a
+	}
+	return b
+}

internal/routes/auth_routes.go

+package routes
+
+import (
+	"context"
+
+	"git.x2erp.com/qdy/go-base/authbase"
+	"git.x2erp.com/qdy/go-base/ctx"
+	"git.x2erp.com/qdy/go-base/model/response"
+	"git.x2erp.com/qdy/go-base/sdk/configure"
+	"git.x2erp.com/qdy/go-base/webx/router"
+)
+
+// RegisterAuthRoutes 注册认证路由
+func RegisterAuthRoutes(ws *router.RouterService, configClient *configure.Client) {
+	// 用户登录（公开端点，无需认证）
+	ws.POST("/api/auth/login",
+		func(req *configure.UserLoginRequest, ctx context.Context, reqCtx *ctx.RequestContext) (*response.QueryResult[string], error) {
+			token, err := configClient.LoginUser(ctx, req)
+			if err != nil {
+				return &response.QueryResult[string]{
+					Success: false,
+					Message: err.Error(),
+				}, nil
+			}
+
+			return &response.QueryResult[string]{
+				Success: true,
+				Data:    token,
+			}, nil
+		},
+	).Desc("用户登录（返回配置中心token）").Register()
+
+	// Token验证端点（需要Token认证，用于测试token有效性）
+	ws.POST("/api/auth/validate",
+		func(ctx context.Context, reqCtx *ctx.RequestContext) (*response.QueryResult[map[string]interface{}], error) {
+			// 如果请求能到达这里，说明TokenAuth中间件已经验证了token
+			// 返回当前用户信息
+			userInfo := map[string]interface{}{
+				"user_id":       reqCtx.UserID,
+				"username":      reqCtx.Username,
+				"tenant_id":     reqCtx.TenantID,
+				"project_id":    reqCtx.ProjectID,
+				"authenticated": true,
+			}
+			return &response.QueryResult[map[string]interface{}]{
+				Success: true,
+				Data:    userInfo,
+			}, nil
+		},
+	).Use(authbase.TokenAuth).Desc("验证token有效性并返回用户信息").Register()
+
+	// 健康检查端点（公开）
+	ws.GET("/api/auth/health",
+		func(ctx context.Context, reqCtx *ctx.RequestContext) (*response.QueryResult[map[string]interface{}], error) {
+			return &response.QueryResult[map[string]interface{}]{
+				Success: true,
+				Data: map[string]interface{}{
+					"status":  "healthy",
+					"service": "svc-code-auth",
+				},
+			}, nil
+		},
+	).Desc("认证服务健康检查").Register()
+}

internal/routes/log_stream_routes.go

 	"net/http"
 	"time"
 
+	"git.x2erp.com/qdy/go-base/authbase"
 	"git.x2erp.com/qdy/go-base/webx/router"
 	"git.x2erp.com/qdy/go-svc-code/internal/opencode"
 )
 	// 这个函数将由 main.go 中的额外注册调用
 }
 
-// LogStreamHandler 日志流的 HTTP 处理器
+// LogStreamHandler 日志流的 HTTP 处理器（已包含TokenAuth认证）
 func LogStreamHandler(process *opencode.Process) http.HandlerFunc {
-	return func(w http.ResponseWriter, r *http.Request) {
+	// 创建内部处理器
+	handler := func(w http.ResponseWriter, r *http.Request) {
 		// 设置 SSE 头
 		w.Header().Set("Content-Type", "text/event-stream")
 		w.Header().Set("Cache-Control", "no-cache")
 			}
 		}
 	}
+
+	// 包装TokenAuth中间件
+	return authbase.TokenAuth(http.HandlerFunc(handler)).ServeHTTP
 }

internal/routes/prompt_stream_routes.go

 	"net/http"
 	"time"
 
+	"git.x2erp.com/qdy/go-base/authbase"
 	"git.x2erp.com/qdy/go-base/ctx"
 	"git.x2erp.com/qdy/go-base/model/response"
 	"git.x2erp.com/qdy/go-base/webx/router"
 
 // RegisterPromptStreamRoutes 注册流式对话路由
 func RegisterPromptStreamRoutes(ws *router.RouterService, client *opencode.Client) {
-	// 流式对话
+	// 流式对话（需要Token认证）
 	ws.POST("/api/prompt/stream",
 		func(req *PromptStreamRequest, ctx context.Context, reqCtx *ctx.RequestContext) (*response.QueryResult[map[string]interface{}], error) {
 			// 流式响应需要直接写入 HTTP 响应，不能使用标准的路由返回值
 				Message: "流式端点需要特殊处理",
 			}, nil
 		},
-	).Desc("流式对话（Server-Sent Events）").Register()
+	).Use(authbase.TokenAuth).Desc("流式对话（Server-Sent Events）").Register()
 
 	// 流式对话的原始 HTTP 处理器
 	// 注意：这个路由需要直接处理 HTTP 流，不能使用标准的 router 包装
 	// 这个函数将由 main.go 中的额外注册调用
 }
 
-// StreamPromptHandler 流式对话的 HTTP 处理器
+// StreamPromptHandler 流式对话的 HTTP 处理器（已包含TokenAuth认证）
 func StreamPromptHandler(client opencode.OpenCodeClient) http.HandlerFunc {
-	return func(w http.ResponseWriter, r *http.Request) {
+	// 创建内部处理器
+	handler := func(w http.ResponseWriter, r *http.Request) {
 		// 解析请求
 		var req PromptStreamRequest
 		if err := BindJSON(r, &req); err != nil {
 			}
 		}
 	}
+
+	// 包装TokenAuth中间件
+	return authbase.TokenAuth(http.HandlerFunc(handler)).ServeHTTP
 }
 
 // BindJSON 简单的 JSON 绑定函数

internal/routes/prompt_sync_routes.go

 import (
 	"context"
 
+	"git.x2erp.com/qdy/go-base/authbase"
 	"git.x2erp.com/qdy/go-base/ctx"
 	"git.x2erp.com/qdy/go-base/model/response"
 	"git.x2erp.com/qdy/go-base/webx/router"
 
 // RegisterPromptSyncRoutes 注册同步对话路由
 func RegisterPromptSyncRoutes(ws *router.RouterService, client opencode.OpenCodeClient) {
-	// 同步对话
+	// 同步对话（需要Token认证）
 	ws.POST("/api/prompt/sync",
 		func(req *PromptSyncRequest, ctx context.Context, reqCtx *ctx.RequestContext) (*response.QueryResult[PromptSyncResponse], error) {
 			prompt := &opencode.PromptRequest{
 				},
 			}, nil
 		},
-	).Desc("同步对话（阻塞等待完整响应）").Register()
+	).Use(authbase.TokenAuth).Desc("同步对话（阻塞等待完整响应）").Register()
 }

internal/routes/session_routes.go

 import (
 	"context"
 
+	"git.x2erp.com/qdy/go-base/authbase"
 	"git.x2erp.com/qdy/go-base/ctx"
 	"git.x2erp.com/qdy/go-base/model/response"
 	"git.x2erp.com/qdy/go-base/webx/router"
 
 // RegisterSessionRoutes 注册会话管理路由
 func RegisterSessionRoutes(ws *router.RouterService, client opencode.OpenCodeClient) {
-	// 创建会话
+	// 创建会话（需要Token认证）
 	ws.POST("/api/session/create",
 		func(req *SessionCreateRequest, ctx context.Context, reqCtx *ctx.RequestContext) (*response.QueryResult[SessionResponse], error) {
 			session, err := client.CreateSession(ctx, req.Title)
 				},
 			}, nil
 		},
-	).Desc("创建新的 opencode 会话").Register()
+	).Use(authbase.TokenAuth).Desc("创建新的 opencode 会话").Register()
 
-	// 获取会话列表
+	// 获取会话列表（需要Token认证）
 	ws.GET("/api/session/list",
 		func(ctx context.Context, reqCtx *ctx.RequestContext) (*response.QueryResult[[]opencode.Session], error) {
 			sessions, err := client.ListSessions(ctx)
 				Data:    sessions,
 			}, nil
 		},
-	).Desc("获取 opencode 会话列表").Register()
+	).Use(authbase.TokenAuth).Desc("获取 opencode 会话列表").Register()
 
 	// 获取单个会话（暂不实现，因为 opencode API 可能不支持）
 	// ws.GET("/api/session/get",

main.go

 	"git.x2erp.com/qdy/go-base/graceful"
 	"git.x2erp.com/qdy/go-base/logger"
 	"git.x2erp.com/qdy/go-base/model/response"
+	"git.x2erp.com/qdy/go-base/sdk/configure"
 	"git.x2erp.com/qdy/go-base/webx"
 	"git.x2erp.com/qdy/go-base/webx/router"
 
 		log.Fatalf("创建 opencode 客户端失败: %v", err)
 	}
 
+	// 4.1 创建配置中心客户端
+	var configClient *configure.Client
+	configClient, err = configure.NewClient()
+	if err != nil {
+		log.Printf("警告: 创建配置中心客户端失败，登录功能将不可用: %v", err)
+		configClient = nil
+	} else {
+		log.Printf("配置中心客户端创建成功，BaseURL: %s", configClient.GetConfig().BaseURL)
+	}
+
 	// 5. 得到 webservice 服务工厂
 	webxFactory := webx.GetWebServiceFactory()
 
 	routerService := router.NewWebService(webService.GetRouter())
 
 	// 8. 注册路由--api
-	registerRoutes(routerService, client, webService)
+	registerRoutes(routerService, client, configClient, webService)
 
 	// 9. 注册前端静态文件服务
 	registerStaticFiles(webService)
 }
 
 // registerRoutes 注册所有 API 路由
-func registerRoutes(ws *router.RouterService, client opencode.OpenCodeClient, webService *webx.WebService) {
+func registerRoutes(ws *router.RouterService, client opencode.OpenCodeClient, configClient *configure.Client, webService *webx.WebService) {
 	// 会话管理路由
 	routes.RegisterSessionRoutes(ws, client)
 
 		webService.GetRouter().Handle("/api/logs/stream", routes.LogStreamHandler(opencodeProcess))
 	}
 
+	// 认证路由
+	if configClient != nil {
+		routes.RegisterAuthRoutes(ws, configClient)
+	}
+
 	// 健康检查路由
 	ws.GET("/api/health", func(reqCtx *ctx.RequestContext) (*response.QueryResult[map[string]interface{}], error) {
 		result := map[string]interface{}{

test/auth_test.go

+package main
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"fmt"
+	"io"
+	"net/http"
+	"os/exec"
+	"testing"
+	"time"
+
+	"git.x2erp.com/qdy/go-base/model/request/queryreq"
+	"git.x2erp.com/qdy/go-base/sdk/configure"
+)
+
+// TestAuthLogin 测试认证登录功能
+func TestAuthLogin(t *testing.T) {
+	// 清理测试缓存
+	cleanTestCache(t)
+
+	// 获取svc-code服务地址
+	svcCodeURL := "http://localhost:8020"
+
+	// 检查svc-code服务是否运行
+	if !isServiceRunning(t, svcCodeURL) {
+		t.Skipf("svc-code服务未运行在 %s，跳过测试", svcCodeURL)
+	}
+
+	// 检查配置中心服务是否运行
+	configureURL := "http://localhost:8080"
+	if !isServiceRunning(t, configureURL) {
+		t.Skipf("配置中心服务未运行在 %s，跳过测试", configureURL)
+	}
+
+	// 测试1：使用SDK直接登录（验证SDK功能）
+	t.Run("SDKLogin", func(t *testing.T) {
+		testSDKLogin(t, configureURL)
+	})
+
+	// 测试2：通过svc-code API登录（验证集成功能）
+	t.Run("APILogin", func(t *testing.T) {
+		testAPILogin(t, svcCodeURL, configureURL)
+	})
+
+	// 测试3：无效凭证登录测试
+	t.Run("InvalidCredentials", func(t *testing.T) {
+		testInvalidCredentials(t, svcCodeURL)
+	})
+}
+
+// testSDKLogin 测试直接使用SDK登录配置中心
+func testSDKLogin(t *testing.T, configureURL string) {
+	// 创建SDK客户端（登录无需认证，但需要BaseURL）
+	client, err := configure.NewBasicAuthClient(configureURL, "test", "test")
+	if err != nil {
+		t.Fatalf("创建SDK客户端失败: %v", err)
+	}
+
+	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
+	defer cancel()
+
+	// 使用测试用户登录
+	req := &configure.UserLoginRequest{
+		UserID:   "test-user-001",
+		Password: "password123",
+	}
+
+	startTime := time.Now()
+	token, err := client.LoginUser(ctx, req)
+	elapsed := time.Since(startTime)
+
+	if err != nil {
+		if isConnectionError(err) {
+			t.Skipf("配置中心连接失败，跳过测试: %v", err)
+		}
+		t.Fatalf("SDK用户登录失败: %v (耗时: %v)", err, elapsed)
+	}
+
+	if token == "" {
+		t.Fatal("SDK用户登录返回空token")
+	}
+
+	t.Logf("SDK用户登录成功！获取Token: %s... (耗时: %v)",
+		token[:min(50, len(token))], elapsed)
+
+	// 验证token可用于创建新的认证客户端
+	tokenClient, err := configure.NewTokenAuthClient(configureURL, token)
+	if err != nil {
+		t.Fatalf("使用获取的token创建客户端失败: %v", err)
+	}
+
+	t.Logf("Token客户端创建成功，BaseURL: %s", tokenClient.GetConfig().BaseURL)
+}
+
+// testAPILogin 测试通过svc-code API登录
+func testAPILogin(t *testing.T, svcCodeURL, configureURL string) {
+	// 创建HTTP客户端
+	httpClient := &http.Client{
+		Timeout: 30 * time.Second,
+	}
+
+	// 准备登录请求
+	loginURL := fmt.Sprintf("%s/api/auth/login", svcCodeURL)
+	loginData := map[string]string{
+		"user_id":  "test-user-001",
+		"password": "password123",
+	}
+	loginJSON, err := json.Marshal(loginData)
+	if err != nil {
+		t.Fatalf("JSON序列化失败: %v", err)
+	}
+
+	// 发送登录请求
+	startTime := time.Now()
+	req, err := http.NewRequest("POST", loginURL, bytes.NewReader(loginJSON))
+	if err != nil {
+		t.Fatalf("创建HTTP请求失败: %v", err)
+	}
+	req.Header.Set("Content-Type", "application/json")
+
+	resp, err := httpClient.Do(req)
+	if err != nil {
+		t.Fatalf("发送登录请求失败: %v", err)
+	}
+	defer resp.Body.Close()
+
+	elapsed := time.Since(startTime)
+
+	// 检查响应状态码
+	if resp.StatusCode != 200 {
+		body, _ := io.ReadAll(resp.Body)
+		t.Fatalf("登录API返回非200状态码: %d, 响应: %s", resp.StatusCode, string(body))
+	}
+
+	// 解析响应
+	body, err := io.ReadAll(resp.Body)
+	if err != nil {
+		t.Fatalf("读取响应体失败: %v", err)
+	}
+
+	var result map[string]interface{}
+	if err := json.Unmarshal(body, &result); err != nil {
+		t.Fatalf("解析响应JSON失败: %v, 响应体: %s", err, string(body))
+	}
+
+	// 检查响应结构
+	if !result["success"].(bool) {
+		t.Fatalf("登录失败: %v", result)
+	}
+
+	token, ok := result["data"].(string)
+	if !ok || token == "" {
+		t.Fatalf("响应中未找到有效token: %v", result)
+	}
+
+	t.Logf("API用户登录成功！获取Token: %s... (耗时: %v)",
+		token[:min(50, len(token))], elapsed)
+
+	// 验证token可用于配置中心
+	t.Run("ValidateTokenWithConfigure", func(t *testing.T) {
+		validateTokenWithConfigure(t, configureURL, token)
+	})
+}
+
+// testInvalidCredentials 测试无效凭证登录
+func testInvalidCredentials(t *testing.T, svcCodeURL string) {
+	httpClient := &http.Client{
+		Timeout: 10 * time.Second,
+	}
+
+	loginURL := fmt.Sprintf("%s/api/auth/login", svcCodeURL)
+	invalidData := map[string]string{
+		"user_id":  "invalid-user",
+		"password": "wrong-password",
+	}
+	invalidJSON, err := json.Marshal(invalidData)
+	if err != nil {
+		t.Fatalf("JSON序列化失败: %v", err)
+	}
+
+	req, err := http.NewRequest("POST", loginURL, bytes.NewReader(invalidJSON))
+	if err != nil {
+		t.Fatalf("创建HTTP请求失败: %v", err)
+	}
+	req.Header.Set("Content-Type", "application/json")
+
+	resp, err := httpClient.Do(req)
+	if err != nil {
+		t.Fatalf("发送登录请求失败: %v", err)
+	}
+	defer resp.Body.Close()
+
+	// 即使凭证无效，API也应该返回200（业务错误通过success字段表示）
+	if resp.StatusCode != 200 {
+		body, _ := io.ReadAll(resp.Body)
+		t.Fatalf("无效凭证登录返回非200状态码: %d, 响应: %s", resp.StatusCode, string(body))
+	}
+
+	body, err := io.ReadAll(resp.Body)
+	if err != nil {
+		t.Fatalf("读取响应体失败: %v", err)
+	}
+
+	var result map[string]interface{}
+	if err := json.Unmarshal(body, &result); err != nil {
+		t.Fatalf("解析响应JSON失败: %v", err)
+	}
+
+	// 无效凭证应该返回success=false
+	if result["success"].(bool) {
+		t.Fatal("无效凭证登录应该失败，但成功了")
+	}
+
+	t.Logf("无效凭证登录失败（预期）: %v", result)
+}
+
+// validateTokenWithConfigure 验证token可用于配置中心
+func validateTokenWithConfigure(t *testing.T, configureURL, token string) {
+	// 使用token创建配置中心客户端
+	client, err := configure.NewTokenAuthClient(configureURL, token)
+	if err != nil {
+		t.Fatalf("使用token创建配置中心客户端失败: %v", err)
+	}
+
+	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
+	defer cancel()
+
+	// 尝试查询表列表（验证token权限）
+	query := &configure.DicTableQueryRequest{
+		QueryRequest: queryreq.QueryRequest{
+			Page:     0,
+			PageSize: 5,
+		},
+	}
+
+	result, err := client.ListTables(ctx, query)
+	if err != nil {
+		// 如果token无效或权限不足，可能失败
+		t.Logf("使用token查询表列表失败（可能是token权限问题）: %v", err)
+	} else {
+		t.Logf("使用token查询表列表成功，总记录数: %d", result.TotalCount)
+	}
+}
+
+// cleanTestCache 清理测试缓存
+func cleanTestCache(t *testing.T) {
+	cmd := exec.Command("go", "clean", "-testcache")
+	if err := cmd.Run(); err != nil {
+		t.Logf("清除测试缓存失败: %v", err)
+	}
+}
+
+// isServiceRunning 检查服务是否运行
+func isServiceRunning(t *testing.T, url string) bool {
+	client := &http.Client{
+		Timeout: 3 * time.Second,
+	}
+
+	// 尝试访问健康检查端点或根路径
+	healthURL := url + "/health"
+	resp, err := client.Get(healthURL)
+	if err != nil {
+		// 也尝试根路径
+		resp, err = client.Get(url)
+		if err != nil {
+			return false
+		}
+	}
+	defer resp.Body.Close()
+
+	return resp.StatusCode == 200 || resp.StatusCode == 404
+}
+
+// isConnectionError 检查错误是否是连接错误
+func isConnectionError(err error) bool {
+	errStr := err.Error()
+	return contains(errStr, "connection refused") ||
+		contains(errStr, "connect: connection refused") ||
+		contains(errStr, "dial tcp") ||
+		contains(errStr, "EOF") ||
+		contains(errStr, "timeout")
+}
+
+// contains 检查字符串是否包含子串
+func contains(s, substr string) bool {
+	return len(s) >= len(substr) && (s == substr || (len(s) > 0 && len(substr) > 0 && (s[0:len(substr)] == substr || contains(s[1:], substr))))
+}
+
+// min 返回两个整数的最小值
+func min(a, b int) int {
+	if a < b {
+		return a
+	}
+	return b
+}
+
+// TestHealthEndpoint 测试健康检查端点
+func TestHealthEndpoint(t *testing.T) {
+	svcCodeURL := "http://localhost:8020"
+
+	if !isServiceRunning(t, svcCodeURL) {
+		t.Skipf("svc-code服务未运行在 %s，跳过测试", svcCodeURL)
+	}
+
+	client := &http.Client{
+		Timeout: 10 * time.Second,
+	}
+
+	resp, err := client.Get(svcCodeURL + "/api/health")
+	if err != nil {
+		t.Fatalf("访问健康检查端点失败: %v", err)
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != 200 {
+		t.Fatalf("健康检查端点返回非200状态码: %d", resp.StatusCode)
+	}
+
+	body, err := io.ReadAll(resp.Body)
+	if err != nil {
+		t.Fatalf("读取响应体失败: %v", err)
+	}
+
+	var result map[string]interface{}
+	if err := json.Unmarshal(body, &result); err != nil {
+		t.Fatalf("解析响应JSON失败: %v", err)
+	}
+
+	if !result["success"].(bool) {
+		t.Fatalf("健康检查返回success=false: %v", result)
+	}
+
+	data := result["data"].(map[string]interface{})
+	if data["status"] != "healthy" {
+		t.Fatalf("健康检查状态不是healthy: %v", data)
+	}
+
+	t.Logf("健康检查端点测试通过: %v", data)
+}