feat: MongoDB replica set multi-host connections

CHANGELOG.md

@@ -9,6 +9,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Added
 
+- MongoDB multi-host connections for replica sets
 - JSON results view mode with Data/Structure/JSON toggle in status bar
 - Import URL: dynamic placeholder, parsed preview, clipboard auto-paste, libSQL/D1 support, URL schemes for Oracle/ClickHouse/etcd/D1/libSQL
 - In-app feedback form for bug reports and feature requests via Help > Report an Issue
@@ -27,6 +28,9 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Fixed
 
+- Connection form overflow with SSH jump hosts and TOTP fields
+- Missing confirmation dialog on group deletion
+- Plugin principalClass resolved off main thread
 - Crash when scrolling AI Chat during streaming on macOS 15.x
 - Connection failure on PostgreSQL-compatible databases (e.g., Aurora DSQL) that don't support `SET statement_timeout`
 - Schema-qualified table names (e.g. `public.users`) now correctly resolve in autocomplete

Plugins/MongoDBDriverPlugin/MongoDBConnection.swift

@@ -177,14 +177,28 @@ final class MongoDBConnection: @unchecked Sendable {
             }
         }
 
-        let encodedHost = host.addingPercentEncoding(withAllowedCharacters: .urlHostAllowed) ?? host
-        let encodedDb = database.addingPercentEncoding(withAllowedCharacters: .urlPathAllowed) ?? database
-
         if useSrv {
+            let encodedHost = host.addingPercentEncoding(withAllowedCharacters: .urlHostAllowed) ?? host
             uri += encodedHost
+        } else if host.contains(",") {
+            let segments = host.split(separator: ",").compactMap { segment -> String? in
+                let parts = segment.split(separator: ":", maxSplits: 1)
+                guard let first = parts.first else { return nil }
+                let h = String(first).trimmingCharacters(in: .whitespaces)
+                guard !h.isEmpty else { return nil }
+                let encodedH = h.addingPercentEncoding(withAllowedCharacters: .urlHostAllowed) ?? h
+                if parts.count > 1 {
+                    return "\(encodedH):\(parts[1].trimmingCharacters(in: .whitespaces))"
+                }
+                return "\(encodedH):\(port)"
+            }
+            uri += segments.isEmpty ? "localhost:\(port)" : segments.joined(separator: ",")
         } else {
+            let encodedHost = host.addingPercentEncoding(withAllowedCharacters: .urlHostAllowed) ?? host
             uri += "\(encodedHost):\(port)"
         }
+
+        let encodedDb = database.addingPercentEncoding(withAllowedCharacters: .urlPathAllowed) ?? database
         uri += database.isEmpty ? "/" : "/\(encodedDb)"
 
         let effectiveAuthSource: String

Plugins/MongoDBDriverPlugin/MongoDBPlugin.swift

@@ -17,6 +17,13 @@ final class MongoDBPlugin: NSObject, TableProPlugin, DriverPlugin {
     static let iconName = "mongodb-icon"
     static let defaultPort = 27017
     static let additionalConnectionFields: [ConnectionField] = [
+        ConnectionField(
+            id: "mongoHosts",
+            label: "Hosts",
+            placeholder: "localhost:27017",
+            fieldType: .hostList,
+            section: .connection
+        ),
         ConnectionField(id: "mongoAuthSource", label: "Auth Database", placeholder: "admin"),
         ConnectionField(
             id: "mongoReadPreference",

Plugins/MongoDBDriverPlugin/MongoDBPluginDriver.swift

@@ -51,8 +51,11 @@ final class MongoDBPluginDriver: PluginDatabaseDriver {
             }
         }
 
+        let effectiveHost = config.additionalFields["mongoHosts"].flatMap { hosts in
+            hosts.isEmpty ? nil : hosts
+        } ?? config.host
         let conn = MongoDBConnection(
-            host: config.host,
+            host: effectiveHost,
             port: config.port,
             user: config.username,
             password: config.password,

Plugins/TableProPluginKit/ConnectionField.swift

@@ -3,6 +3,7 @@ import Foundation
 public enum FieldSection: String, Codable, Sendable {
     case authentication
     case advanced
+    case connection
 }
 
 public struct FieldVisibilityRule: Codable, Sendable, Equatable {
@@ -67,6 +68,7 @@ public struct ConnectionField: Codable, Sendable {
         case number
         case toggle
         case stepper(range: IntRange)
+        case hostList
     }
 
     public struct DropdownOption: Codable, Sendable, Equatable {

TablePro/Core/Plugins/PluginManager.swift

@@ -176,26 +176,19 @@ final class PluginManager {
     }
 
     /// Holds the result of loading a single plugin bundle off the main thread.
-    /// Bundle is not formally Sendable but is thread-safe for property reads after load().
+    /// Only stores the loaded Bundle and its origin. Protocol property reads
+    /// (principalClass, static vars) happen later on @MainActor in registerLoadedPlugins
+    /// to avoid ObjC runtime thread-safety issues during initial class resolution.
     private struct LoadedBundle: @unchecked Sendable {
         let url: URL
         let source: PluginSource
         let bundle: Bundle
-        let principalClassName: String
-
-        // These are extracted off-main since they're static protocol properties
-        let pluginName: String
-        let pluginVersion: String
-        let pluginDescription: String
-        let capabilities: [PluginCapability]
-        let databaseTypeId: String?
-        let additionalTypeIds: [String]
-        let pluginIconName: String
-        let defaultPort: Int?
     }
 
-    /// Perform the expensive bundle.load() and principalClass resolution off MainActor.
-    /// Returns successfully loaded bundles with their metadata extracted.
+    /// Perform the expensive bundle.load() off MainActor (dynamic linker I/O).
+    /// Does NOT access bundle.principalClass — that triggers ObjC runtime dispatch
+    /// that is not thread-safe during initial resolution. Version checks use Info.plist
+    /// which is safe after load().
     nonisolated private static func loadBundlesOffMain(
         _ pending: [(url: URL, source: PluginSource)]
     ) async -> [LoadedBundle] {
@@ -234,62 +227,48 @@ final class PluginManager {
                 continue
             }
 
-            guard let principalClass = bundle.principalClass as? any TableProPlugin.Type else {
-                logger.error("Principal class does not conform to TableProPlugin: \(entry.url.lastPathComponent)")
-                continue
-            }
-
-            let driverType = principalClass as? any DriverPlugin.Type
-            let version = readRegistryVersion(for: entry.url) ?? principalClass.pluginVersion
-            let loaded = LoadedBundle(
-                url: entry.url,
-                source: entry.source,
-                bundle: bundle,
-                principalClassName: NSStringFromClass(principalClass),
-                pluginName: principalClass.pluginName,
-                pluginVersion: version,
-                pluginDescription: principalClass.pluginDescription,
-                capabilities: principalClass.capabilities,
-                databaseTypeId: driverType?.databaseTypeId,
-                additionalTypeIds: driverType?.additionalDatabaseTypeIds ?? [],
-                pluginIconName: driverType?.iconName ?? "puzzlepiece",
-                defaultPort: driverType?.defaultPort
-            )
-            results.append(loaded)
+            results.append(LoadedBundle(url: entry.url, source: entry.source, bundle: bundle))
         }
         return results
     }
 
     /// Register pre-loaded bundles into the plugin dictionaries. Must be called on MainActor.
+    /// Resolves principalClass and reads all static protocol properties here (safe on main thread)
+    /// rather than in loadBundlesOffMain where ObjC runtime dispatch is not thread-safe.
     private func registerLoadedPlugins(_ loaded: [LoadedBundle]) {
         let disabled = disabledPluginIds
 
         for item in loaded {
+            guard let principalClass = item.bundle.principalClass as? any TableProPlugin.Type else {
+                Self.logger.error("Principal class does not conform to TableProPlugin: \(item.url.lastPathComponent)")
+                continue
+            }
+
             let bundleId = item.bundle.bundleIdentifier ?? item.url.lastPathComponent
+            let driverType = principalClass as? any DriverPlugin.Type
+            let version = Self.readRegistryVersion(for: item.url) ?? principalClass.pluginVersion
             let entry = PluginEntry(
                 id: bundleId,
                 bundle: item.bundle,
                 url: item.url,
                 source: item.source,
-                name: item.pluginName,
-                version: item.pluginVersion,
-                pluginDescription: item.pluginDescription,
-                capabilities: item.capabilities,
+                name: principalClass.pluginName,
+                version: version,
+                pluginDescription: principalClass.pluginDescription,
+                capabilities: principalClass.capabilities,
                 isEnabled: !disabled.contains(bundleId),
-                databaseTypeId: item.databaseTypeId,
-                additionalTypeIds: item.additionalTypeIds,
-                pluginIconName: item.pluginIconName,
-                defaultPort: item.defaultPort
+                databaseTypeId: driverType?.databaseTypeId,
+                additionalTypeIds: driverType?.additionalDatabaseTypeIds ?? [],
+                pluginIconName: driverType?.iconName ?? "puzzlepiece",
+                defaultPort: driverType?.defaultPort
             )
 
             plugins.append(entry)
+            validateCapabilityDeclarations(principalClass, pluginId: bundleId)
 
-            if let principalClass = item.bundle.principalClass as? any TableProPlugin.Type {
-                validateCapabilityDeclarations(principalClass, pluginId: bundleId)
-                if entry.isEnabled {
-                    let instance = principalClass.init()
-                    registerCapabilities(instance, pluginId: bundleId)
-                }
+            if entry.isEnabled {
+                let instance = principalClass.init()
+                registerCapabilities(instance, pluginId: bundleId)
             }
 
             Self.logger.info("Loaded plugin '\(entry.name)' v\(entry.version) [\(item.source == .builtIn ? "built-in" : "user")]")

TablePro/Core/Plugins/PluginMetadataRegistry+RegistryDefaults.swift

@@ -549,6 +549,13 @@ extension PluginMetadataRegistry {
                 ),
                 connection: PluginMetadataSnapshot.ConnectionConfig(
                     additionalConnectionFields: [
+                        ConnectionField(
+                            id: "mongoHosts",
+                            label: "Hosts",
+                            placeholder: "localhost:27017",
+                            fieldType: .hostList,
+                            section: .connection
+                        ),
                         ConnectionField(
                             id: "mongoAuthSource", label: "Auth Database", placeholder: "admin"
                         ),

TablePro/Core/Utilities/Connection/ConnectionURLParser.swift

@@ -35,18 +35,20 @@ struct ParsedConnectionURL {
     let oracleServiceName: String?
     let useSrv: Bool
     let mongoQueryParams: [String: String]
+    let multiHost: String?
 
     var suggestedName: String {
         if let connectionName, !connectionName.isEmpty {
             return connectionName
         }
         let typeName = type.rawValue
+        let displayHost = multiHost?.split(separator: ",").first.map(String.init) ?? host
         let displayDatabase = database.isEmpty ? (oracleServiceName ?? "") : database
         if !displayDatabase.isEmpty {
-            return "\(typeName) \(host)/\(displayDatabase)"
+            return "\(typeName) \(displayHost)/\(displayDatabase)"
         }
-        if !host.isEmpty {
-            return "\(typeName) \(host)"
+        if !displayHost.isEmpty {
+            return "\(typeName) \(displayHost)"
         }
         return typeName
     }
@@ -162,14 +164,23 @@ struct ConnectionURLParser {
                 filterCondition: nil,
                 oracleServiceName: nil,
                 useSrv: false,
-                mongoQueryParams: [:]
+                mongoQueryParams: [:],
+                multiHost: nil
             ))
         }
 
         if isSSH {
             return parseSSHURL(trimmed, schemeEnd: schemeEnd, dbType: dbType)
         }
 
+        // Multi-host MongoDB URI: URLComponents can't parse comma-separated hosts
+        if dbType == .mongodb && !isSrv {
+            let afterScheme = String(trimmed[schemeEnd.upperBound...])
+            if let multiHostResult = parseMultiHostMongoDB(afterScheme, dbType: dbType, isSrv: isSrv) {
+                return .success(multiHostResult)
+            }
+        }
+
         let httpURL = "http://" + String(trimmed[schemeEnd.upperBound...])
         guard let components = URLComponents(string: httpURL) else {
             return .failure(.invalidURL)
@@ -256,7 +267,8 @@ struct ConnectionURLParser {
             filterCondition: ext.filterCondition,
             oracleServiceName: oracleServiceName,
             useSrv: ext.useSrv,
-            mongoQueryParams: ext.mongoQueryParams
+            mongoQueryParams: ext.mongoQueryParams,
+            multiHost: nil
         ))
     }
 
@@ -389,10 +401,107 @@ struct ConnectionURLParser {
             filterCondition: ext.filterCondition,
             oracleServiceName: oracleServiceName,
             useSrv: ext.useSrv,
-            mongoQueryParams: ext.mongoQueryParams
+            mongoQueryParams: ext.mongoQueryParams,
+            multiHost: nil
         ))
     }
 
+    // MARK: - Multi-Host MongoDB Parsing
+
+    private static func parseMultiHostMongoDB(
+        _ afterScheme: String,
+        dbType: DatabaseType,
+        isSrv: Bool
+    ) -> ParsedConnectionURL? {
+        var mainPart = afterScheme
+        var queryString: String?
+        if let questionIndex = afterScheme.firstIndex(of: "?") {
+            mainPart = String(afterScheme[afterScheme.startIndex..<questionIndex])
+            queryString = String(afterScheme[afterScheme.index(after: questionIndex)...])
+        }
+
+        var authority = mainPart
+        var database = ""
+        if let slashIndex = mainPart.firstIndex(of: "/") {
+            authority = String(mainPart[mainPart.startIndex..<slashIndex])
+            database = String(mainPart[mainPart.index(after: slashIndex)...])
+                .removingPercentEncoding ?? String(mainPart[mainPart.index(after: slashIndex)...])
+        }
+
+        var credentials = ""
+        var hostPortion = authority
+        if let atIndex = authority.lastIndex(of: "@") {
+            credentials = String(authority[authority.startIndex..<atIndex])
+            hostPortion = String(authority[authority.index(after: atIndex)...])
+        }
+
+        guard hostPortion.contains(",") else { return nil }
+
+        var username = ""
+        var password = ""
+        if !credentials.isEmpty {
+            if let colonIndex = credentials.firstIndex(of: ":") {
+                username = String(credentials[credentials.startIndex..<colonIndex])
+                    .removingPercentEncoding ?? ""
+                password = String(credentials[credentials.index(after: colonIndex)...])
+                    .removingPercentEncoding ?? ""
+            } else {
+                username = credentials.removingPercentEncoding ?? ""
+            }
+        }
+
+        let multiHost = hostPortion
+
+        let firstSegment = hostPortion.split(separator: ",").first.map(String.init) ?? hostPortion
+        let hostParts = firstSegment.split(separator: ":", maxSplits: 1)
+        let firstHost = String(hostParts[0]).removingPercentEncoding ?? String(hostParts[0])
+        let firstPort: Int? = hostParts.count > 1 ? Int(hostParts[1]) : nil
+
+        var queryItems: [URLQueryItem]?
+        if let qs = queryString {
+            queryItems = qs.split(separator: "&").map { param in
+                let kv = param.split(separator: "=", maxSplits: 1)
+                let key = String(kv[0])
+                let val = kv.count > 1 ? (String(kv[1]).removingPercentEncoding ?? String(kv[1])) : ""
+                return URLQueryItem(name: key, value: val)
+            }
+        }
+
+        let ext = parseQueryItems(queryItems, dbType: dbType)
+
+        return ParsedConnectionURL(
+            type: dbType,
+            host: firstHost,
+            port: firstPort,
+            database: database,
+            username: username,
+            password: password,
+            sslMode: ext.sslMode,
+            authSource: ext.authSource,
+            sshHost: nil,
+            sshPort: nil,
+            sshUsername: nil,
+            usePrivateKey: nil,
+            useSSHAgent: nil,
+            agentSocket: nil,
+            connectionName: ext.connectionName,
+            redisDatabase: nil,
+            statusColor: ext.statusColor,
+            envTag: ext.envTag,
+            schema: ext.schema,
+            tableName: ext.tableName,
+            isView: ext.isView,
+            filterColumn: ext.filterColumn,
+            filterOperation: ext.filterOperation,
+            filterValue: ext.filterValue,
+            filterCondition: ext.filterCondition,
+            oracleServiceName: nil,
+            useSrv: isSrv,
+            mongoQueryParams: ext.mongoQueryParams,
+            multiHost: multiHost
+        )
+    }
+
     // MARK: - Query Parameter Helpers
 
     private struct ExtendedParams {