feat(http-tunnel): 支持独立 HTTP 隧道连接并覆盖多数据源

refs #168

frontend/package.json.md5

@@ -1 +1 @@
-5b8157374dae5f9340e31b2d0bd2c00e
+d0f9366af59a6367ad3c7e2d4185ead4

frontend/src/components/ConnectionModal.tsx

@@ -101,6 +101,7 @@ const ConnectionModal: React.FC<{
   const [useSSL, setUseSSL] = useState(false);
   const [useSSH, setUseSSH] = useState(false);
   const [useProxy, setUseProxy] = useState(false);
+  const [useHttpTunnel, setUseHttpTunnel] = useState(false);
   const [dbType, setDbType] = useState('mysql');
   const [step, setStep] = useState(1); // 1: Select Type, 2: Configure
   const [activeGroup, setActiveGroup] = useState(0); // Active category index in step 1
@@ -1026,6 +1027,8 @@ const ConnectionModal: React.FC<{
               const mysqlIsReplica = String(config.topology || '').toLowerCase() === 'replica' || mysqlReplicaHosts.length > 0;
               const mongoIsReplica = String(config.topology || '').toLowerCase() === 'replica' || mongoHosts.length > 0 || !!config.replicaSet;
               const redisIsCluster = String(config.topology || '').toLowerCase() === 'cluster' || redisHosts.length > 0;
+              const hasHttpTunnel = !!config.useHttpTunnel;
+              const hasProxy = !hasHttpTunnel && !!config.useProxy;
               form.setFieldsValue({
                   type: configType,
                   name: initialValues.name,
@@ -1047,12 +1050,17 @@ const ConnectionModal: React.FC<{
                   sshUser: config.ssh?.user,
                   sshPassword: config.ssh?.password,
                   sshKeyPath: config.ssh?.keyPath,
-                  useProxy: config.useProxy,
+                  useProxy: hasProxy,
                   proxyType: config.proxy?.type || 'socks5',
                   proxyHost: config.proxy?.host,
                   proxyPort: config.proxy?.port,
                   proxyUser: config.proxy?.user,
                   proxyPassword: config.proxy?.password,
+                  useHttpTunnel: hasHttpTunnel,
+                  httpTunnelHost: config.httpTunnel?.host,
+                  httpTunnelPort: config.httpTunnel?.port || 8080,
+                  httpTunnelUser: config.httpTunnel?.user,
+                  httpTunnelPassword: config.httpTunnel?.password,
                   driver: config.driver,
                   dsn: config.dsn,
                   timeout: config.timeout || 30,
@@ -1076,7 +1084,8 @@ const ConnectionModal: React.FC<{
               });
               setUseSSL(!!config.useSSL);
               setUseSSH(config.useSSH || false);
-              setUseProxy(config.useProxy || false);
+              setUseProxy(hasProxy);
+              setUseHttpTunnel(hasHttpTunnel);
               setDbType(configType);
               // 如果是 Redis 编辑模式，设置已保存的 Redis 数据库列表
               if (configType === 'redis') {
@@ -1089,6 +1098,7 @@ const ConnectionModal: React.FC<{
               setUseSSL(false);
               setUseSSH(false);
               setUseProxy(false);
+              setUseHttpTunnel(false);
               setDbType('mysql');
               setActiveGroup(0);
           }
@@ -1140,6 +1150,7 @@ const ConnectionModal: React.FC<{
       setUseSSL(false);
       setUseSSH(false);
       setUseProxy(false);
+      setUseHttpTunnel(false);
       setDbType('mysql');
       setStep(1);
       onClose();
@@ -1388,7 +1399,8 @@ const ConnectionModal: React.FC<{
           password: mergedValues.sshPassword || "",
           keyPath: mergedValues.sshKeyPath || ""
       } : { host: "", port: 22, user: "", password: "", keyPath: "" };
-      const effectiveUseProxy = !isFileDbType && !!mergedValues.useProxy;
+      const effectiveUseHttpTunnel = !isFileDbType && !!mergedValues.useHttpTunnel;
+      const effectiveUseProxy = !isFileDbType && !!mergedValues.useProxy && !effectiveUseHttpTunnel;
       const proxyTypeRaw = String(mergedValues.proxyType || 'socks5').toLowerCase();
       const proxyType: 'socks5' | 'http' = proxyTypeRaw === 'http' ? 'http' : 'socks5';
       const proxyConfig: NonNullable<ConnectionConfig['proxy']> = effectiveUseProxy ? {
@@ -1404,6 +1416,25 @@ const ConnectionModal: React.FC<{
           user: '',
           password: '',
       };
+      const httpTunnelConfig: NonNullable<ConnectionConfig['httpTunnel']> = effectiveUseHttpTunnel ? {
+          host: String(mergedValues.httpTunnelHost || '').trim(),
+          port: Number(mergedValues.httpTunnelPort || 8080),
+          user: String(mergedValues.httpTunnelUser || '').trim(),
+          password: mergedValues.httpTunnelPassword || "",
+      } : {
+          host: '',
+          port: 8080,
+          user: '',
+          password: '',
+      };
+      if (effectiveUseHttpTunnel) {
+          if (!httpTunnelConfig.host) {
+              throw new Error('HTTP 隧道主机不能为空');
+          }
+          if (!Number.isFinite(httpTunnelConfig.port) || httpTunnelConfig.port <= 0 || httpTunnelConfig.port > 65535) {
+              throw new Error('HTTP 隧道端口必须在 1-65535 之间');
+          }
+      }
 
       const keepPassword = !forPersist || savePassword;
 
@@ -1423,6 +1454,8 @@ const ConnectionModal: React.FC<{
           ssh: sshConfig,
           useProxy: effectiveUseProxy,
           proxy: proxyConfig,
+          useHttpTunnel: effectiveUseHttpTunnel,
+          httpTunnel: httpTunnelConfig,
           driver: mergedValues.driver,
           dsn: mergedValues.dsn,
           timeout: Number(mergedValues.timeout || 30),
@@ -1461,6 +1494,7 @@ const ConnectionModal: React.FC<{
           setUseSSL(false);
           setUseSSH(false);
           setUseProxy(false);
+          setUseHttpTunnel(false);
           form.setFieldsValue({
               host: '',
               port: 0,
@@ -1483,6 +1517,11 @@ const ConnectionModal: React.FC<{
               proxyPort: 1080,
               proxyUser: '',
               proxyPassword: '',
+              useHttpTunnel: false,
+              httpTunnelHost: '',
+              httpTunnelPort: 8080,
+              httpTunnelUser: '',
+              httpTunnelPassword: '',
               mysqlTopology: 'single',
               redisTopology: 'single',
               mongoTopology: 'single',
@@ -1505,6 +1544,7 @@ const ConnectionModal: React.FC<{
           const defaultUser = type === 'clickhouse' ? 'default' : 'root';
           const sslCapableType = supportsSSLForType(type);
           setUseSSL(false);
+          setUseHttpTunnel(false);
           form.setFieldsValue({
               user: defaultUser,
               database: '',
@@ -1513,6 +1553,11 @@ const ConnectionModal: React.FC<{
               sslMode: sslCapableType ? 'preferred' : undefined,
               sslCertPath: sslCapableType ? '' : undefined,
               sslKeyPath: sslCapableType ? '' : undefined,
+              useHttpTunnel: false,
+              httpTunnelHost: '',
+              httpTunnelPort: 8080,
+              httpTunnelUser: '',
+              httpTunnelPassword: '',
               mysqlTopology: 'single',
               redisTopology: 'single',
               mongoTopology: 'single',
@@ -1665,6 +1710,8 @@ const ConnectionModal: React.FC<{
             useProxy: false,
             proxyType: 'socks5',
             proxyPort: 1080,
+            useHttpTunnel: false,
+            httpTunnelPort: 8080,
             timeout: 30,
             uri: '',
             mysqlTopology: 'single',
@@ -1693,7 +1740,14 @@ const ConnectionModal: React.FC<{
             }
             if (changed.useSSL !== undefined) setUseSSL(changed.useSSL);
             if (changed.useSSH !== undefined) setUseSSH(changed.useSSH);
-            if (changed.useProxy !== undefined) setUseProxy(changed.useProxy);
+            if (changed.useProxy !== undefined) {
+                const enabledProxy = !!changed.useProxy;
+                setUseProxy(enabledProxy);
+                if (enabledProxy && form.getFieldValue('useHttpTunnel')) {
+                    form.setFieldValue('useHttpTunnel', false);
+                    setUseHttpTunnel(false);
+                }
+            }
             if (changed.proxyType !== undefined) {
                 const nextType = String(changed.proxyType || 'socks5').toLowerCase();
                 if (nextType === 'http') {
@@ -1708,6 +1762,20 @@ const ConnectionModal: React.FC<{
                     }
                 }
             }
+            if (changed.useHttpTunnel !== undefined) {
+                const enabledHttpTunnel = !!changed.useHttpTunnel;
+                setUseHttpTunnel(enabledHttpTunnel);
+                if (enabledHttpTunnel && form.getFieldValue('useProxy')) {
+                    form.setFieldValue('useProxy', false);
+                    setUseProxy(false);
+                }
+                if (enabledHttpTunnel) {
+                    const currentPort = Number(form.getFieldValue('httpTunnelPort') || 0);
+                    if (!currentPort || currentPort <= 0) {
+                        form.setFieldValue('httpTunnelPort', 8080);
+                    }
+                }
+            }
             // Type change handled by step 1, but keep sync if select changes (hidden now)
             if (changed.type !== undefined) setDbType(changed.type);
             if (changed.redisTopology !== undefined) {
@@ -2194,6 +2262,35 @@ const ConnectionModal: React.FC<{
                 </div>
             )}
 
+            <Divider style={{ margin: '12px 0' }} />
+            <Form.Item name="useHttpTunnel" valuePropName="checked" style={{ marginBottom: 0 }}>
+                <Checkbox>使用 HTTP 隧道（独立代理）</Checkbox>
+            </Form.Item>
+
+            {useHttpTunnel && (
+                <div style={tunnelSectionStyle}>
+                    <div style={{ display: 'flex', gap: 16 }}>
+                        <Form.Item name="httpTunnelHost" label="隧道主机" rules={[{ required: useHttpTunnel, message: '请输入隧道主机' }]} style={{ flex: 1 }}>
+                            <Input placeholder="例如: tunnel.company.com 或 127.0.0.1" />
+                        </Form.Item>
+                        <Form.Item name="httpTunnelPort" label="端口" rules={[{ required: useHttpTunnel, message: '请输入隧道端口' }]} style={{ width: 120 }}>
+                            <InputNumber style={{ width: '100%' }} min={1} max={65535} />
+                        </Form.Item>
+                    </div>
+                    <div style={{ display: 'flex', gap: 16 }}>
+                        <Form.Item name="httpTunnelUser" label="隧道用户名（可选）" style={{ flex: 1 }}>
+                            <Input placeholder="留空表示无认证" />
+                        </Form.Item>
+                        <Form.Item name="httpTunnelPassword" label="隧道密码（可选）" style={{ flex: 1 }}>
+                            <Input.Password placeholder="留空表示无认证" />
+                        </Form.Item>
+                    </div>
+                    <Text type="secondary" style={{ fontSize: 12 }}>
+                        与“使用代理”互斥，启用后将通过 HTTP CONNECT 建立独立隧道。
+                    </Text>
+                </div>
+            )}
+
             <Divider style={{ margin: '12px 0' }} />
             
             <Collapse 

frontend/src/components/Sidebar.tsx

@@ -382,6 +382,16 @@ const Sidebar: React.FC<{ onEditConnection?: (conn: SavedConnection) => void }>
       password: readString(rawProxy.password, rawProxy.Password, cloned.proxyPassword, cloned.ProxyPassword),
     };
     const hasProxyDetail = Boolean(normalizedProxy.host || normalizedProxy.user || normalizedProxy.password);
+    const rawHttpTunnel = (cloned.httpTunnel ?? cloned.HTTPTunnel ?? {}) as Record<string, unknown>;
+    const normalizedHttpTunnel = {
+      host: readString(rawHttpTunnel.host, rawHttpTunnel.Host, cloned.httpTunnelHost, cloned.HttpTunnelHost),
+      port: readNumber(8080, rawHttpTunnel.port, rawHttpTunnel.Port, cloned.httpTunnelPort, cloned.HttpTunnelPort),
+      user: readString(rawHttpTunnel.user, rawHttpTunnel.User, cloned.httpTunnelUser, cloned.HttpTunnelUser),
+      password: readString(rawHttpTunnel.password, rawHttpTunnel.Password, cloned.httpTunnelPassword, cloned.HttpTunnelPassword),
+    };
+    const hasHttpTunnelDetail = Boolean(normalizedHttpTunnel.host || normalizedHttpTunnel.user || normalizedHttpTunnel.password);
+    const normalizedUseHttpTunnel = readBool(hasHttpTunnelDetail, cloned.useHttpTunnel, cloned.UseHTTPTunnel);
+    const normalizedUseProxy = !normalizedUseHttpTunnel && readBool(hasProxyDetail, cloned.useProxy, cloned.UseProxy);
 
     const rawHosts = Array.isArray(cloned.hosts)
       ? cloned.hosts
@@ -394,8 +404,10 @@ const Sidebar: React.FC<{ onEditConnection?: (conn: SavedConnection) => void }>
       ...(cloned as SavedConnection['config']),
       useSSH: readBool(hasSSHDetail, cloned.useSSH, cloned.UseSSH),
       ssh: normalizedSSH,
-      useProxy: readBool(hasProxyDetail, cloned.useProxy, cloned.UseProxy),
+      useProxy: normalizedUseProxy,
       proxy: normalizedProxy,
+      useHttpTunnel: normalizedUseHttpTunnel,
+      httpTunnel: normalizedHttpTunnel,
       hosts: normalizedHosts,
       timeout: readNumber(30, cloned.timeout, cloned.Timeout),
     };

frontend/src/store.ts

@@ -231,6 +231,18 @@ const sanitizeConnectionConfig = (value: unknown): ConnectionConfig => {
     user: toTrimmedString(proxyRaw.user),
     password: toTrimmedString(proxyRaw.password),
   };
+  const httpTunnelRaw = (raw.httpTunnel && typeof raw.httpTunnel === 'object')
+    ? raw.httpTunnel as Record<string, unknown>
+    : ((raw.HTTPTunnel && typeof raw.HTTPTunnel === 'object') ? raw.HTTPTunnel as Record<string, unknown> : {});
+  const httpTunnel = {
+    host: toTrimmedString(httpTunnelRaw.host ?? raw.httpTunnelHost),
+    port: normalizePort(httpTunnelRaw.port ?? raw.httpTunnelPort, 8080),
+    user: toTrimmedString(httpTunnelRaw.user ?? raw.httpTunnelUser),
+    password: toTrimmedString(httpTunnelRaw.password ?? raw.httpTunnelPassword),
+  };
+  const supportsNetworkTunnel = type !== 'sqlite' && type !== 'duckdb';
+  const useHttpTunnel = supportsNetworkTunnel && (raw.useHttpTunnel === true || raw.UseHTTPTunnel === true);
+  const useProxy = supportsNetworkTunnel && !!raw.useProxy && !useHttpTunnel;
 
   const safeConfig: ConnectionConfig & Record<string, unknown> = {
     ...raw,
@@ -247,8 +259,10 @@ const sanitizeConnectionConfig = (value: unknown): ConnectionConfig => {
     sslKeyPath: sslCapable ? toTrimmedString(raw.sslKeyPath) : '',
     useSSH: !!raw.useSSH,
     ssh,
-    useProxy: !!raw.useProxy,
+    useProxy,
     proxy,
+    useHttpTunnel,
+    httpTunnel,
     uri: toTrimmedString(raw.uri).slice(0, MAX_URI_LENGTH),
     hosts: sanitizeAddressList(raw.hosts),
     topology: raw.topology === 'replica' ? 'replica' : (raw.topology === 'cluster' ? 'cluster' : 'single'),

frontend/src/types.ts

@@ -14,6 +14,13 @@ export interface ProxyConfig {
   password?: string;
 }
 
+export interface HTTPTunnelConfig {
+  host: string;
+  port: number;
+  user?: string;
+  password?: string;
+}
+
 export interface ConnectionConfig {
   type: string;
   host: string;
@@ -30,6 +37,8 @@ export interface ConnectionConfig {
   ssh?: SSHConfig;
   useProxy?: boolean;
   proxy?: ProxyConfig;
+  useHttpTunnel?: boolean;
+  httpTunnel?: HTTPTunnelConfig;
   driver?: string;
   dsn?: string;
   timeout?: number;

frontend/wailsjs/go/models.ts

@@ -48,6 +48,24 @@ export namespace connection {
 		    return a;
 		}
 	}
+	export class HTTPTunnelConfig {
+	    host: string;
+	    port: number;
+	    user?: string;
+	    password?: string;
+	
+	    static createFrom(source: any = {}) {
+	        return new HTTPTunnelConfig(source);
+	    }
+	
+	    constructor(source: any = {}) {
+	        if ('string' === typeof source) source = JSON.parse(source);
+	        this.host = source["host"];
+	        this.port = source["port"];
+	        this.user = source["user"];
+	        this.password = source["password"];
+	    }
+	}
 	export class ProxyConfig {
 	    type: string;
 	    host: string;
@@ -104,6 +122,8 @@ export namespace connection {
 	    ssh: SSHConfig;
 	    useProxy?: boolean;
 	    proxy?: ProxyConfig;
+	    useHttpTunnel?: boolean;
+	    httpTunnel?: HTTPTunnelConfig;
 	    driver?: string;
 	    dsn?: string;
 	    timeout?: number;
@@ -142,6 +162,8 @@ export namespace connection {
 	        this.ssh = this.convertValues(source["ssh"], SSHConfig);
 	        this.useProxy = source["useProxy"];
 	        this.proxy = this.convertValues(source["proxy"], ProxyConfig);
+	        this.useHttpTunnel = source["useHttpTunnel"];
+	        this.httpTunnel = this.convertValues(source["httpTunnel"], HTTPTunnelConfig);
 	        this.driver = source["driver"];
 	        this.dsn = source["dsn"];
 	        this.timeout = source["timeout"];
@@ -179,6 +201,7 @@ export namespace connection {
 		}
 	}
 	
+	
 	export class QueryResult {
 	    success: boolean;
 	    message: string;

internal/app/app.go

@@ -96,6 +96,9 @@ func normalizeCacheKeyConfig(config connection.ConnectionConfig) connection.Conn
 	if !normalized.UseProxy {
 		normalized.Proxy = connection.ProxyConfig{}
 	}
+	if !normalized.UseHTTPTunnel {
+		normalized.HTTPTunnel = connection.HTTPTunnelConfig{}
+	}
 
 	if isFileDatabaseType(normalized.Type) {
 		dsn := strings.TrimSpace(normalized.Host)
@@ -124,6 +127,8 @@ func normalizeCacheKeyConfig(config connection.ConnectionConfig) connection.Conn
 		normalized.MongoAuthMechanism = ""
 		normalized.MongoReplicaUser = ""
 		normalized.MongoReplicaPassword = ""
+		normalized.UseHTTPTunnel = false
+		normalized.HTTPTunnel = connection.HTTPTunnelConfig{}
 	}
 
 	return normalized
@@ -303,6 +308,12 @@ func formatConnSummary(config connection.ConnectionConfig) string {
 			b.WriteString(" 代理认证=已配置")
 		}
 	}
+	if config.UseHTTPTunnel {
+		b.WriteString(fmt.Sprintf(" HTTP隧道=%s:%d", strings.TrimSpace(config.HTTPTunnel.Host), config.HTTPTunnel.Port))
+		if strings.TrimSpace(config.HTTPTunnel.User) != "" {
+			b.WriteString(" HTTP隧道认证=已配置")
+		}
+	}
 
 	if config.Type == "custom" {
 		driver := strings.TrimSpace(config.Driver)

internal/app/db_proxy.go

@@ -12,8 +12,35 @@ import (
 
 func resolveDialConfigWithProxy(raw connection.ConnectionConfig) (connection.ConnectionConfig, error) {
 	config := raw
+	if config.UseHTTPTunnel {
+		if config.UseProxy {
+			return connection.ConnectionConfig{}, fmt.Errorf("HTTP 隧道与普通代理不能同时启用")
+		}
+		tunnelHost := strings.TrimSpace(config.HTTPTunnel.Host)
+		if tunnelHost == "" {
+			return connection.ConnectionConfig{}, fmt.Errorf("HTTP 隧道主机不能为空")
+		}
+		tunnelPort := config.HTTPTunnel.Port
+		if tunnelPort <= 0 {
+			tunnelPort = 8080
+		}
+		if tunnelPort > 65535 {
+			return connection.ConnectionConfig{}, fmt.Errorf("HTTP 隧道端口无效：%d", config.HTTPTunnel.Port)
+		}
+
+		config.UseProxy = true
+		config.Proxy = connection.ProxyConfig{
+			Type:     "http",
+			Host:     tunnelHost,
+			Port:     tunnelPort,
+			User:     strings.TrimSpace(config.HTTPTunnel.User),
+			Password: config.HTTPTunnel.Password,
+		}
+	}
 	if !config.UseProxy {
 		config.Proxy = connection.ProxyConfig{}
+		config.UseHTTPTunnel = false
+		config.HTTPTunnel = connection.HTTPTunnelConfig{}
 		return config, nil
 	}
 
@@ -22,6 +49,8 @@ func resolveDialConfigWithProxy(raw connection.ConnectionConfig) (connection.Con
 		return connection.ConnectionConfig{}, err
 	}
 	config.Proxy = normalizedProxy
+	config.UseHTTPTunnel = false
+	config.HTTPTunnel = connection.HTTPTunnelConfig{}
 
 	if config.UseSSH {
 		sshPort := config.SSH.Port

internal/app/global_proxy.go

@@ -110,7 +110,7 @@ func (a *App) GetGlobalProxyConfig() connection.QueryResult {
 
 func applyGlobalProxyToConnection(config connection.ConnectionConfig) connection.ConnectionConfig {
 	effective := config
-	if effective.UseProxy {
+	if effective.UseProxy || effective.UseHTTPTunnel {
 		return effective
 	}
 	if isFileDatabaseType(effective.Type) {

internal/app/methods_redis.go

@@ -23,12 +23,20 @@ var (
 
 // getRedisClient gets or creates a Redis client from cache
 func (a *App) getRedisClient(config connection.ConnectionConfig) (redis.RedisClient, error) {
-	key := getRedisClientCacheKey(config)
+	effectiveConfig := applyGlobalProxyToConnection(config)
+	connectConfig, proxyErr := resolveDialConfigWithProxy(effectiveConfig)
+	if proxyErr != nil {
+		wrapped := wrapConnectError(effectiveConfig, proxyErr)
+		logger.Error(wrapped, "Redis 代理准备失败：%s", formatRedisConnSummary(effectiveConfig))
+		return nil, wrapped
+	}
+
+	key := getRedisClientCacheKey(connectConfig)
 	shortKey := key
 	if len(shortKey) > 12 {
 		shortKey = shortKey[:12]
 	}
-	logger.Infof("获取 Redis 连接：%s 缓存Key=%s", formatRedisConnSummary(config), shortKey)
+	logger.Infof("获取 Redis 连接：%s 缓存Key=%s", formatRedisConnSummary(effectiveConfig), shortKey)
 
 	redisCacheMu.Lock()
 	defer redisCacheMu.Unlock()
@@ -47,21 +55,20 @@ func (a *App) getRedisClient(config connection.ConnectionConfig) (redis.RedisCli
 
 	logger.Infof("创建 Redis 客户端实例：缓存Key=%s", shortKey)
 	client := redis.NewRedisClient()
-	if err := client.Connect(config); err != nil {
-		logger.Error(err, "Redis 连接失败：%s 缓存Key=%s", formatRedisConnSummary(config), shortKey)
-		return nil, err
+	if err := client.Connect(connectConfig); err != nil {
+		wrapped := wrapConnectError(effectiveConfig, err)
+		logger.Error(wrapped, "Redis 连接失败：%s 缓存Key=%s", formatRedisConnSummary(effectiveConfig), shortKey)
+		return nil, wrapped
 	}
 
 	redisCache[key] = client
-	logger.Infof("Redis 连接成功并写入缓存：%s 缓存Key=%s", formatRedisConnSummary(config), shortKey)
+	logger.Infof("Redis 连接成功并写入缓存：%s 缓存Key=%s", formatRedisConnSummary(effectiveConfig), shortKey)
 	return client, nil
 }
 
 func getRedisClientCacheKey(config connection.ConnectionConfig) string {
-	if !config.UseSSH {
-		config.SSH = connection.SSHConfig{}
-	}
-	b, _ := json.Marshal(config)
+	normalized := normalizeCacheKeyConfig(config)
+	b, _ := json.Marshal(normalized)
 	sum := sha256.Sum256(b)
 	return hex.EncodeToString(sum[:])
 }
@@ -91,6 +98,26 @@ func formatRedisConnSummary(config connection.ConnectionConfig) string {
 		b.WriteString(" 用户=")
 		b.WriteString(config.SSH.User)
 	}
+	if config.UseProxy {
+		b.WriteString(" 代理=")
+		b.WriteString(strings.ToLower(strings.TrimSpace(config.Proxy.Type)))
+		b.WriteString("://")
+		b.WriteString(config.Proxy.Host)
+		b.WriteString(":")
+		b.WriteString(strconv.Itoa(config.Proxy.Port))
+		if strings.TrimSpace(config.Proxy.User) != "" {
+			b.WriteString(" 代理认证=已配置")
+		}
+	}
+	if config.UseHTTPTunnel {
+		b.WriteString(" HTTP隧道=")
+		b.WriteString(strings.TrimSpace(config.HTTPTunnel.Host))
+		b.WriteString(":")
+		b.WriteString(strconv.Itoa(config.HTTPTunnel.Port))
+		if strings.TrimSpace(config.HTTPTunnel.User) != "" {
+			b.WriteString(" HTTP隧道认证=已配置")
+		}
+	}
 
 	return b.String()
 }

internal/connection/types.go

@@ -18,39 +18,49 @@ type ProxyConfig struct {
 	Password string `json:"password,omitempty"`
 }
 
+// HTTPTunnelConfig holds independent HTTP CONNECT tunnel details
+type HTTPTunnelConfig struct {
+	Host     string `json:"host"`
+	Port     int    `json:"port"`
+	User     string `json:"user,omitempty"`
+	Password string `json:"password,omitempty"`
+}
+
 // ConnectionConfig holds database connection details including SSH
 type ConnectionConfig struct {
-	Type                 string      `json:"type"`
-	Host                 string      `json:"host"`
-	Port                 int         `json:"port"`
-	User                 string      `json:"user"`
-	Password             string      `json:"password"`
-	SavePassword         bool        `json:"savePassword,omitempty"` // Persist password in saved connection
-	Database             string      `json:"database"`
-	UseSSL               bool        `json:"useSSL,omitempty"`      // MySQL-like SSL/TLS switch
-	SSLMode              string      `json:"sslMode,omitempty"`     // preferred | required | skip-verify | disable
-	SSLCertPath          string      `json:"sslCertPath,omitempty"` // TLS client certificate path (e.g., Dameng)
-	SSLKeyPath           string      `json:"sslKeyPath,omitempty"`  // TLS client private key path (e.g., Dameng)
-	UseSSH               bool        `json:"useSSH"`
-	SSH                  SSHConfig   `json:"ssh"`
-	UseProxy             bool        `json:"useProxy,omitempty"`
-	Proxy                ProxyConfig `json:"proxy,omitempty"`
-	Driver               string      `json:"driver,omitempty"`               // For custom connection
-	DSN                  string      `json:"dsn,omitempty"`                  // For custom connection
-	Timeout              int         `json:"timeout,omitempty"`              // Connection timeout in seconds (default: 30)
-	RedisDB              int         `json:"redisDB,omitempty"`              // Redis database index (0-15)
-	URI                  string      `json:"uri,omitempty"`                  // Connection URI for copy/paste
-	Hosts                []string    `json:"hosts,omitempty"`                // Multi-host addresses: host:port
-	Topology             string      `json:"topology,omitempty"`             // single | replica | cluster
-	MySQLReplicaUser     string      `json:"mysqlReplicaUser,omitempty"`     // MySQL replica auth user
-	MySQLReplicaPassword string      `json:"mysqlReplicaPassword,omitempty"` // MySQL replica auth password
-	ReplicaSet           string      `json:"replicaSet,omitempty"`           // MongoDB replica set name
-	AuthSource           string      `json:"authSource,omitempty"`           // MongoDB authSource
-	ReadPreference       string      `json:"readPreference,omitempty"`       // MongoDB readPreference
-	MongoSRV             bool        `json:"mongoSrv,omitempty"`             // MongoDB use mongodb+srv URI scheme
-	MongoAuthMechanism   string      `json:"mongoAuthMechanism,omitempty"`   // MongoDB authMechanism
-	MongoReplicaUser     string      `json:"mongoReplicaUser,omitempty"`     // MongoDB replica auth user
-	MongoReplicaPassword string      `json:"mongoReplicaPassword,omitempty"` // MongoDB replica auth password
+	Type                 string           `json:"type"`
+	Host                 string           `json:"host"`
+	Port                 int              `json:"port"`
+	User                 string           `json:"user"`
+	Password             string           `json:"password"`
+	SavePassword         bool             `json:"savePassword,omitempty"` // Persist password in saved connection
+	Database             string           `json:"database"`
+	UseSSL               bool             `json:"useSSL,omitempty"`      // MySQL-like SSL/TLS switch
+	SSLMode              string           `json:"sslMode,omitempty"`     // preferred | required | skip-verify | disable
+	SSLCertPath          string           `json:"sslCertPath,omitempty"` // TLS client certificate path (e.g., Dameng)
+	SSLKeyPath           string           `json:"sslKeyPath,omitempty"`  // TLS client private key path (e.g., Dameng)
+	UseSSH               bool             `json:"useSSH"`
+	SSH                  SSHConfig        `json:"ssh"`
+	UseProxy             bool             `json:"useProxy,omitempty"`
+	Proxy                ProxyConfig      `json:"proxy,omitempty"`
+	UseHTTPTunnel        bool             `json:"useHttpTunnel,omitempty"`
+	HTTPTunnel           HTTPTunnelConfig `json:"httpTunnel,omitempty"`
+	Driver               string           `json:"driver,omitempty"`               // For custom connection
+	DSN                  string           `json:"dsn,omitempty"`                  // For custom connection
+	Timeout              int              `json:"timeout,omitempty"`              // Connection timeout in seconds (default: 30)
+	RedisDB              int              `json:"redisDB,omitempty"`              // Redis database index (0-15)
+	URI                  string           `json:"uri,omitempty"`                  // Connection URI for copy/paste
+	Hosts                []string         `json:"hosts,omitempty"`                // Multi-host addresses: host:port
+	Topology             string           `json:"topology,omitempty"`             // single | replica | cluster
+	MySQLReplicaUser     string           `json:"mysqlReplicaUser,omitempty"`     // MySQL replica auth user
+	MySQLReplicaPassword string           `json:"mysqlReplicaPassword,omitempty"` // MySQL replica auth password
+	ReplicaSet           string           `json:"replicaSet,omitempty"`           // MongoDB replica set name
+	AuthSource           string           `json:"authSource,omitempty"`           // MongoDB authSource
+	ReadPreference       string           `json:"readPreference,omitempty"`       // MongoDB readPreference
+	MongoSRV             bool             `json:"mongoSrv,omitempty"`             // MongoDB use mongodb+srv URI scheme
+	MongoAuthMechanism   string           `json:"mongoAuthMechanism,omitempty"`   // MongoDB authMechanism
+	MongoReplicaUser     string           `json:"mongoReplicaUser,omitempty"`     // MongoDB replica auth user
+	MongoReplicaPassword string           `json:"mongoReplicaPassword,omitempty"` // MongoDB replica auth password
 }
 
 // QueryResult is the standard response format for Wails methods