Release/0.5.7 (#226)

* 🎨 style(DataGrid): 清理冗余代码与静态分析告警 - 类型重构：通过修正 React Context 的函数签名解决了 void 类型的链式调用错误 - 代码精简：利用 Nullish Coalescing (??) 优化组件配置项降级逻辑，剥离无意义的隐式 undefined 赋值 - 工具链适配：适配 IDE 拼写检查与 Promise strict rules，确保全文件零警 * 🔧 fix(db/kingbase_impl): 修复标识符无条件加双引号导致SQL语法报错 - quoteKingbaseIdent 改为条件引用，仅对大写字母、保留字、特殊字符的标识符添加双引号 - 新增 kingbaseIdentNeedsQuote 判断标识符是否需要引用 - 新增 isKingbaseReservedWord 检测常见SQL保留字 - 补充 TestQuoteKingbaseIdent、TestKingbaseIdentNeedsQuote 单测覆盖各场景 - refs #176 * 🔧 fix(release,db/kingbase_impl): 修复金仓默认 schema 并静默生成 DMG - Kingbase：在 current_schema() 为 public 时探测候选 schema，并通过 DSN search_path 重连，兼容未限定 schema 的查询 - 候选优先级：数据库名/用户名同名 schema（存在性校验），否则仅在“唯一用户 schema 有表”场景兜底 - 避免连接污染：每次 Connect 重置探测结果，重连成功后替换连接并关闭旧连接 - 打包脚本：create-dmg 增加 --sandbox-safe，避免构建时自动弹出/打开挂载窗口 - 产物格式：强制 --format UDZO，并将 rw.*.dmg/UDRW 中间产物转换为可分发 DMG - 校验门禁：增加 hdiutil verify，失败时保留 .app 便于排查，同时修正卷图标探测并补 ad-hoc 签名 * 🐛 fix(connection/redis): 修复 Redis URI 用户名处理导致认证失败 - Redis URI 解析回填 user 字段，兼容 redis://user:pass@... 与 redis://:pass@... - 生成 URI 时按需输出 user/password，避免丢失用户名信息 - Redis 类型默认用户名置空，并在构建配置时清理历史默认 root - 避免 go-redis 触发 ACL AUTH(user, pass) 导致 WRONGPASS - refs #212 * 🔧 fix(release,ssh): 修复 SSH 误判连接成功并纠正 DMG 打包结构 - SSH 缓存 key 纳入认证指纹（password/keyPath），避免改错凭证仍复用旧连接/端口转发 - MySQL/MariaDB/Doris：SSH 隧道建立失败直接返回错误，不再回退直连导致测试误判成功 - 新增最小单测覆盖 SSH cache key 与 UseSSH 异常路径 - build-release.sh：create-dmg 使用 staging 目录作为 source，避免 DMG 根目录变成 Contents - refs #213 * fix: KingBase 连接后自动设置 search_path，修复自定义 schema 下表查询报 relation does not exist 的问题 (#215) * 🔧 fix(driver/kingbase,mongodb): 修复外置驱动事务引用与连接测试链路问题 - 金仓外置驱动链路增加表名与变更字段归一化，修复 ApplyChanges 场景下双引号转义异常导致的 SQL 语法错误 - 新增金仓公共标识符工具并复用到 kingbase_impl 与 optional_driver_agent_impl，统一处理多重转义、schema.table 拆分与引用规范 - 金仓代理连接后自动探测并设置 search_path，降低查询时必须手写 schema 前缀的概率 - MongoDB 连接参数改为显式 host/hosts 优先，避免被 URI 中 localhost 覆盖；代理链路保留目标地址不再改写为本地地址 - 连接测试增加前后端超时收敛与日志增强，避免长时间转圈；连接错误文案在未启用 TLS 时移除误导性的“SSL”前缀 - 统一日志级别为 INFO/WARN/ERROR，默认日志目录收敛到 ~/.GoNavi/Logs，并补充驱动构建脚本 build-driver-agents.sh * 🔧 fix(release/sidebar): 统一跨平台UPX压缩并修复PG函数列表查询兼容性 - 构建脚本新增通用 UPX 压缩函数，覆盖 macOS、Linux、Windows 产物 - 本地打包改为强制压缩策略：未安装 upx、压缩失败或校验失败直接终止 - macOS 打包在签名前压缩 .app 主程序并执行 upx -t 校验 - Linux 打包在生成 tar.gz 前压缩可执行文件并执行 upx -t 校验 - GitHub Release 与测试构建流程补齐 macOS/Linux/Windows 的 upx 安装与压缩步骤 - PostgreSQL/PG-like 函数元数据查询增加多路兼容 SQL，修复函数列表不显示问题 - refs #221 - refs #222 --------- Co-authored-by: Syngnat <yangguofeng919@gmail.com> Co-authored-by: 凌封 <49424247+fengin@users.noreply.github.com>
2026-06-06 06:29:35 +08:00 · 2026-03-12 17:40:35 +08:00
parent 6ad690cffc
commit eaa45f17fd
38 changed files with 2997 additions and 489 deletions
--- a/internal/app/app.go
+++ b/internal/app/app.go
@@ -8,6 +8,8 @@ import (
 	"errors"
 	"fmt"
 	"net"
+	"net/url"
+	"os"
 	"strings"
 	"sync"
 	"time"
@@ -218,6 +220,7 @@ func wrapConnectError(config connection.ConnectionConfig, err error) error {
 	if err == nil {
 		return nil
 	}
+	err = sanitizeMongoConnectErrorLabel(config, err)

 	var netErr net.Error
 	if errors.Is(err, context.DeadlineExceeded) || (errors.As(err, &netErr) && netErr.Timeout()) {
@@ -231,6 +234,73 @@ func wrapConnectError(config connection.ConnectionConfig, err error) error {
 	return withLogHint{err: err, logPath: logger.Path()}
 }

+type errorMessageOverride struct {
+	message string
+	cause   error
+}
+
+func (e errorMessageOverride) Error() string {
+	return e.message
+}
+
+func (e errorMessageOverride) Unwrap() error {
+	return e.cause
+}
+
+func sanitizeMongoConnectErrorLabel(config connection.ConnectionConfig, err error) error {
+	if err == nil {
+		return nil
+	}
+	if strings.ToLower(strings.TrimSpace(config.Type)) != "mongodb" {
+		return err
+	}
+	if mongoConnectUsesTLS(config) {
+		return err
+	}
+	original := err.Error()
+	rewritten := strings.ReplaceAll(original, "SSL 主库凭据", "主库凭据")
+	rewritten = strings.ReplaceAll(rewritten, "SSL 从库凭据", "从库凭据")
+	if rewritten == original {
+		return err
+	}
+	return errorMessageOverride{
+		message: rewritten,
+		cause:   err,
+	}
+}
+
+func mongoConnectUsesTLS(config connection.ConnectionConfig) bool {
+	if config.UseSSL {
+		return true
+	}
+	uriText := strings.TrimSpace(config.URI)
+	if uriText == "" {
+		return false
+	}
+	parsed, err := url.Parse(uriText)
+	if err != nil {
+		return false
+	}
+	for _, key := range []string{"tls", "ssl"} {
+		if enabled, known := parseMongoBool(parsed.Query().Get(key)); known {
+			return enabled
+		}
+	}
+	return strings.EqualFold(strings.TrimSpace(parsed.Scheme), "mongodb+srv")
+}
+
+func parseMongoBool(raw string) (enabled bool, known bool) {
+	value := strings.ToLower(strings.TrimSpace(raw))
+	switch value {
+	case "1", "true", "t", "yes", "y", "on", "required":
+		return true, true
+	case "0", "false", "f", "no", "n", "off", "disable", "disabled":
+		return false, true
+	default:
+		return false, false
+	}
+}
+
 type withLogHint struct {
 	err     error
 	logPath string
@@ -238,10 +308,15 @@ type withLogHint struct {

 func (e withLogHint) Error() string {
 	message := normalizeErrorMessage(e.err)
-	if strings.TrimSpace(e.logPath) == "" {
+	path := strings.TrimSpace(e.logPath)
+	if path == "" {
 		return message
 	}
-	return fmt.Sprintf("%s（详细日志：%s）", message, e.logPath)
+	info, statErr := os.Stat(path)
+	if statErr != nil || info.IsDir() || info.Size() <= 0 {
+		return message
+	}
+	return fmt.Sprintf("%s（详细日志：%s）", message, path)
 }

 func (e withLogHint) Unwrap() error {
--- a/internal/app/app_connect_error_test.go
+++ b/internal/app/app_connect_error_test.go
@@ -0,0 +1,84 @@
+package app
+
+import (
+	"errors"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+
+	"GoNavi-Wails/internal/connection"
+)
+
+func TestWrapConnectError_MongoNoSSL_RemovesMisleadingSSLLabel(t *testing.T) {
+	config := connection.ConnectionConfig{
+		Type:   "mongodb",
+		UseSSL: false,
+	}
+	sourceErr := errors.New("MongoDB 连接失败：SSL 主库凭据验证失败: mock error")
+
+	wrapped := wrapConnectError(config, sourceErr)
+	text := wrapped.Error()
+	if strings.Contains(text, "SSL 主库凭据") {
+		t.Fatalf("expected ssl label to be removed when TLS disabled, got: %s", text)
+	}
+	if !strings.Contains(text, "主库凭据验证失败") {
+		t.Fatalf("expected auth label to remain, got: %s", text)
+	}
+}
+
+func TestWrapConnectError_MongoURIForcesTLS_KeepsSSLLabel(t *testing.T) {
+	config := connection.ConnectionConfig{
+		Type:   "mongodb",
+		UseSSL: false,
+		URI:    "mongodb://user:pass@127.0.0.1:27017/admin?tls=true",
+	}
+	sourceErr := errors.New("MongoDB 连接失败：SSL 主库凭据验证失败: mock error")
+
+	wrapped := wrapConnectError(config, sourceErr)
+	text := wrapped.Error()
+	if !strings.Contains(text, "SSL 主库凭据") {
+		t.Fatalf("expected ssl label to remain when URI enables TLS, got: %s", text)
+	}
+}
+
+func TestWrapConnectError_MongoSRVDefaultTLS_KeepsSSLLabel(t *testing.T) {
+	config := connection.ConnectionConfig{
+		Type:   "mongodb",
+		UseSSL: false,
+		URI:    "mongodb+srv://user:pass@cluster0.example.com/admin",
+	}
+	sourceErr := errors.New("MongoDB 连接失败：SSL 主库凭据验证失败: mock error")
+
+	wrapped := wrapConnectError(config, sourceErr)
+	text := wrapped.Error()
+	if !strings.Contains(text, "SSL 主库凭据") {
+		t.Fatalf("expected ssl label to remain for mongodb+srv default TLS, got: %s", text)
+	}
+}
+
+func TestWithLogHintError_OmitEmptyLogPath(t *testing.T) {
+	dir := t.TempDir()
+	logPath := filepath.Join(dir, "gonavi.log")
+	if err := os.WriteFile(logPath, nil, 0o644); err != nil {
+		t.Fatalf("write empty log failed: %v", err)
+	}
+	err := withLogHint{err: errors.New("连接失败"), logPath: logPath}
+	text := err.Error()
+	if strings.Contains(text, "详细日志：") {
+		t.Fatalf("expected no log hint for empty file, got: %s", text)
+	}
+}
+
+func TestWithLogHintError_IncludeNonEmptyLogPath(t *testing.T) {
+	dir := t.TempDir()
+	logPath := filepath.Join(dir, "gonavi.log")
+	if err := os.WriteFile(logPath, []byte("log entry\n"), 0o644); err != nil {
+		t.Fatalf("write log failed: %v", err)
+	}
+	err := withLogHint{err: errors.New("连接失败"), logPath: logPath}
+	text := err.Error()
+	if !strings.Contains(text, "详细日志："+logPath) {
+		t.Fatalf("expected log hint with path, got: %s", text)
+	}
+}
--- a/internal/app/db_proxy.go
+++ b/internal/app/db_proxy.go
@@ -73,8 +73,8 @@ func resolveDialConfigWithProxy(raw connection.ConnectionConfig) (connection.Con
 		// 文件型/自定义 DSN 类型不走标准 host:port，不在此层改写。
 		return config, nil
 	}
-	if normalizedType == "mongodb" && config.MongoSRV {
-		// Mongo SRV 由驱动侧 Dialer 处理代理，避免破坏 DNS SRV 拓扑发现。
+	if normalizedType == "mongodb" {
+		// MongoDB 统一由驱动侧 Dialer 处理代理，保留原始目标地址，避免将连接目标改写为本地转发地址。
 		return config, nil
 	}

--- a/internal/app/db_proxy_test.go
+++ b/internal/app/db_proxy_test.go
@@ -0,0 +1,64 @@
+package app
+
+import (
+	"reflect"
+	"testing"
+
+	"GoNavi-Wails/internal/connection"
+)
+
+func TestResolveDialConfigWithProxy_MongoKeepsTargetAddress(t *testing.T) {
+	hosts := []string{"10.20.30.40:27017", "10.20.30.41:27017"}
+	raw := connection.ConnectionConfig{
+		Type:     "mongodb",
+		Host:     "10.20.30.40",
+		Port:     27017,
+		UseProxy: true,
+		Proxy: connection.ProxyConfig{
+			Type: "socks5",
+			Host: "127.0.0.1",
+			Port: 1080,
+		},
+		Hosts: hosts,
+	}
+
+	got, err := resolveDialConfigWithProxy(raw)
+	if err != nil {
+		t.Fatalf("resolveDialConfigWithProxy returned error: %v", err)
+	}
+	if got.Host != raw.Host || got.Port != raw.Port {
+		t.Fatalf("mongo target address should be kept, got=%s:%d want=%s:%d", got.Host, got.Port, raw.Host, raw.Port)
+	}
+	if !got.UseProxy {
+		t.Fatalf("mongo should keep UseProxy=true for driver-level dialer")
+	}
+	if !reflect.DeepEqual(got.Hosts, hosts) {
+		t.Fatalf("mongo hosts should be kept, got=%v want=%v", got.Hosts, hosts)
+	}
+}
+
+func TestResolveDialConfigWithProxy_MongoSRVKeepsTargetAddress(t *testing.T) {
+	raw := connection.ConnectionConfig{
+		Type:     "mongodb",
+		Host:     "cluster0.example.com",
+		Port:     27017,
+		MongoSRV: true,
+		UseProxy: true,
+		Proxy: connection.ProxyConfig{
+			Type: "http",
+			Host: "127.0.0.1",
+			Port: 7890,
+		},
+	}
+
+	got, err := resolveDialConfigWithProxy(raw)
+	if err != nil {
+		t.Fatalf("resolveDialConfigWithProxy returned error: %v", err)
+	}
+	if got.Host != raw.Host || got.Port != raw.Port {
+		t.Fatalf("mongo SRV target address should be kept, got=%s:%d want=%s:%d", got.Host, got.Port, raw.Host, raw.Port)
+	}
+	if !got.UseProxy {
+		t.Fatalf("mongo SRV should keep UseProxy=true for driver-level dialer")
+	}
+}
--- a/internal/app/global_proxy.go
+++ b/internal/app/global_proxy.go
@@ -72,25 +72,30 @@ func setGlobalProxyConfig(enabled bool, proxyConfig connection.ProxyConfig) (glo
 }

 func (a *App) ConfigureGlobalProxy(enabled bool, proxyConfig connection.ProxyConfig) connection.QueryResult {
+	before := currentGlobalProxyConfig()
 	snapshot, err := setGlobalProxyConfig(enabled, proxyConfig)
 	if err != nil {
 		return connection.QueryResult{Success: false, Message: err.Error()}
 	}

-	if snapshot.Enabled {
-		authState := ""
-		if strings.TrimSpace(snapshot.Proxy.User) != "" {
-			authState = "（认证：已配置）"
+	// 前端可能在同一配置下重复触发同步（例如严格模式或状态回放），
+	// 这里做幂等日志，避免重复刷屏。
+	if !globalProxySnapshotEqual(before, snapshot) {
+		if snapshot.Enabled {
+			authState := ""
+			if strings.TrimSpace(snapshot.Proxy.User) != "" {
+				authState = "（认证：已配置）"
+			}
+			logger.Infof(
+				"全局代理已启用：%s://%s:%d%s",
+				strings.ToLower(strings.TrimSpace(snapshot.Proxy.Type)),
+				strings.TrimSpace(snapshot.Proxy.Host),
+				snapshot.Proxy.Port,
+				authState,
+			)
+		} else {
+			logger.Infof("全局代理已关闭")
 		}
-		logger.Infof(
-			"全局代理已启用：%s://%s:%d%s",
-			strings.ToLower(strings.TrimSpace(snapshot.Proxy.Type)),
-			strings.TrimSpace(snapshot.Proxy.Host),
-			snapshot.Proxy.Port,
-			authState,
-		)
-	} else {
-		logger.Infof("全局代理已关闭")
 	}

 	return connection.QueryResult{
@@ -100,6 +105,24 @@ func (a *App) ConfigureGlobalProxy(enabled bool, proxyConfig connection.ProxyCon
 	}
 }

+func globalProxySnapshotEqual(a, b globalProxySnapshot) bool {
+	if a.Enabled != b.Enabled {
+		return false
+	}
+	if !a.Enabled {
+		return true
+	}
+	return proxyConfigEqual(a.Proxy, b.Proxy)
+}
+
+func proxyConfigEqual(a, b connection.ProxyConfig) bool {
+	return strings.EqualFold(strings.TrimSpace(a.Type), strings.TrimSpace(b.Type)) &&
+		strings.TrimSpace(a.Host) == strings.TrimSpace(b.Host) &&
+		a.Port == b.Port &&
+		strings.TrimSpace(a.User) == strings.TrimSpace(b.User) &&
+		a.Password == b.Password
+}
+
 func (a *App) GetGlobalProxyConfig() connection.QueryResult {
 	return connection.QueryResult{
 		Success: true,
--- a/internal/app/methods_db.go
+++ b/internal/app/methods_db.go
@@ -13,6 +13,16 @@ import (
 	"GoNavi-Wails/internal/utils"
 )

+const testConnectionTimeoutUpperBoundSeconds = 12
+
+func normalizeTestConnectionConfig(config connection.ConnectionConfig) connection.ConnectionConfig {
+	normalized := config
+	if normalized.Timeout <= 0 || normalized.Timeout > testConnectionTimeoutUpperBoundSeconds {
+		normalized.Timeout = testConnectionTimeoutUpperBoundSeconds
+	}
+	return normalized
+}
+
 // Generic DB Methods

 func (a *App) DBConnect(config connection.ConnectionConfig) connection.QueryResult {
@@ -28,13 +38,16 @@ func (a *App) DBConnect(config connection.ConnectionConfig) connection.QueryResu
 }

 func (a *App) TestConnection(config connection.ConnectionConfig) connection.QueryResult {
-	_, err := a.getDatabaseForcePing(config)
+	testConfig := normalizeTestConnectionConfig(config)
+	started := time.Now()
+	logger.Infof("TestConnection 开始：%s", formatConnSummary(testConfig))
+	_, err := a.getDatabaseForcePing(testConfig)
 	if err != nil {
-		logger.Error(err, "TestConnection 连接测试失败：%s", formatConnSummary(config))
+		logger.Error(err, "TestConnection 连接测试失败：耗时=%s %s", time.Since(started).Round(time.Millisecond), formatConnSummary(testConfig))
 		return connection.QueryResult{Success: false, Message: err.Error()}
 	}

-	logger.Infof("TestConnection 连接测试成功：%s", formatConnSummary(config))
+	logger.Infof("TestConnection 连接测试成功：耗时=%s %s", time.Since(started).Round(time.Millisecond), formatConnSummary(testConfig))
 	return connection.QueryResult{Success: true, Message: "连接成功"}
 }

--- a/internal/app/methods_db_timeout_test.go
+++ b/internal/app/methods_db_timeout_test.go
@@ -0,0 +1,31 @@
+package app
+
+import (
+	"testing"
+
+	"GoNavi-Wails/internal/connection"
+)
+
+func TestNormalizeTestConnectionConfig_DefaultToUpperBound(t *testing.T) {
+	config := connection.ConnectionConfig{Type: "mongodb", Timeout: 0}
+	got := normalizeTestConnectionConfig(config)
+	if got.Timeout != testConnectionTimeoutUpperBoundSeconds {
+		t.Fatalf("expected timeout=%d, got=%d", testConnectionTimeoutUpperBoundSeconds, got.Timeout)
+	}
+}
+
+func TestNormalizeTestConnectionConfig_KeepSmallerTimeout(t *testing.T) {
+	config := connection.ConnectionConfig{Type: "mongodb", Timeout: 6}
+	got := normalizeTestConnectionConfig(config)
+	if got.Timeout != 6 {
+		t.Fatalf("expected timeout=6, got=%d", got.Timeout)
+	}
+}
+
+func TestNormalizeTestConnectionConfig_ClampLargeTimeout(t *testing.T) {
+	config := connection.ConnectionConfig{Type: "mongodb", Timeout: 60}
+	got := normalizeTestConnectionConfig(config)
+	if got.Timeout != testConnectionTimeoutUpperBoundSeconds {
+		t.Fatalf("expected timeout=%d, got=%d", testConnectionTimeoutUpperBoundSeconds, got.Timeout)
+	}
+}
--- a/internal/app/methods_driver.go
+++ b/internal/app/methods_driver.go
@@ -2792,6 +2792,7 @@ func ensureOptionalDriverAgentBinary(a *App, definition driverDefinition, execut
 	driverType := normalizeDriverType(definition.Type)
 	displayName := resolveDriverDisplayName(definition)
 	forceSourceBuild := shouldForceSourceBuildForVersion(driverType, selectedVersion)
+	preferSourceBuildBeforeDownload := shouldPreferSourceBuildBeforeDownload(driverType, selectedVersion)
 	skipReuseCandidate := shouldSkipReusableAgentCandidate(driverType, selectedVersion)

 	info, err := os.Stat(executablePath)
@@ -2799,11 +2800,10 @@ func ensureOptionalDriverAgentBinary(a *App, definition driverDefinition, execut
 		if validateErr := db.ValidateOptionalDriverAgentExecutable(driverType, executablePath); validateErr != nil {
 			_ = os.Remove(executablePath)
 		} else {
-			hash, hashErr := hashFileSHA256(executablePath)
-			if hashErr != nil {
-				return "", "", fmt.Errorf("读取已安装 %s 驱动代理摘要失败：%w", displayName, hashErr)
+			// 用户点击“安装/重装”时应强制刷新驱动代理，避免沿用旧二进制导致修复不生效。
+			if removeErr := os.Remove(executablePath); removeErr != nil {
+				return "", "", fmt.Errorf("清理已安装 %s 驱动代理失败：%w", displayName, removeErr)
 			}
-			return fmt.Sprintf("local://existing/%s-driver-agent", driverType), hash, nil
 		}
 	}
 	if err == nil && info.IsDir() {
@@ -2834,6 +2834,22 @@ func ensureOptionalDriverAgentBinary(a *App, definition driverDefinition, execut
 	}

 	var downloadErrs []string
+	var sourceBuildAttempted bool
+	var sourceBuildErr error
+
+	if !forceSourceBuild && preferSourceBuildBeforeDownload {
+		sourceBuildAttempted = true
+		if a != nil {
+			a.emitDriverDownloadProgress(driverType, "downloading", 16, 100, fmt.Sprintf("优先使用本地源码构建 %s 驱动代理", displayName))
+		}
+		hash, buildErr := buildOptionalDriverAgentFromSource(definition, executablePath, selectedVersion)
+		if buildErr == nil {
+			return fmt.Sprintf("local://go-build/%s-driver-agent", driverType), hash, nil
+		}
+		sourceBuildErr = buildErr
+		logger.Warnf("预先本地构建 %s 驱动代理失败，将继续尝试下载预编译包：%v", displayName, buildErr)
+	}
+
 	if !forceSourceBuild {
 		downloadURLs := resolveOptionalDriverAgentDownloadURLs(definition, downloadURL)
 		if len(downloadURLs) > 0 {
@@ -2866,9 +2882,15 @@ func ensureOptionalDriverAgentBinary(a *App, definition driverDefinition, execut
 		a.emitDriverDownloadProgress(driverType, "downloading", 92, 100, "未命中预编译包，尝试开发态本地构建")
 	}

-	hash, buildErr := buildOptionalDriverAgentFromSource(definition, executablePath, selectedVersion)
-	if buildErr == nil {
-		return fmt.Sprintf("local://go-build/%s-driver-agent", driverType), hash, nil
+	var buildErr error
+	if sourceBuildAttempted {
+		buildErr = sourceBuildErr
+	} else {
+		hash, runErr := buildOptionalDriverAgentFromSource(definition, executablePath, selectedVersion)
+		buildErr = runErr
+		if buildErr == nil {
+			return fmt.Sprintf("local://go-build/%s-driver-agent", driverType), hash, nil
+		}
 	}

 	var parts []string
@@ -3086,12 +3108,25 @@ func shouldForceSourceBuildForVersion(driverType string, selectedVersion string)
 	return resolveMongoDriverMajorFromVersion(selectedVersion) == 1
 }

-func shouldSkipReusableAgentCandidate(driverType string, selectedVersion string) bool {
-	if normalizeDriverType(driverType) != "mongodb" {
+func shouldPreferSourceBuildBeforeDownload(driverType string, selectedVersion string) bool {
+	_ = selectedVersion
+	switch normalizeDriverType(driverType) {
+	case "kingbase":
+		// 金仓迭代期优先本地源码构建，避免下载到旧版本预编译代理导致修复不生效。
+		return true
+	default:
 		return false
 	}
+}
+
+func shouldSkipReusableAgentCandidate(driverType string, selectedVersion string) bool {
 	_ = selectedVersion
-	return true
+	switch normalizeDriverType(driverType) {
+	case "mongodb", "kingbase":
+		return true
+	default:
+		return false
+	}
 }

 func optionalDriverBuildTag(driverType string, selectedVersion string) (string, error) {