fix(ssh): allow empty username in form when alias supplies User from ssh config

Author: datlechin

TablePro/Core/SSH/LibSSH2TunnelFactory.swift

@@ -125,6 +125,12 @@ internal enum LibSSH2TunnelFactory {
         let resolvedJumps: [ResolvedSSHTarget] = (formJumps.isEmpty ? resolvedPrimary.proxyJump : formJumps)
             .map { SSHConfigResolver.resolve($0, document: document) }
 
+        if resolvedPrimary.username.isEmpty {
+            throw SSHTunnelError.tunnelCreationFailed(
+                "SSH username not set. Add it to the form or set `User` for `\(config.host)` in ~/.ssh/config."
+            )
+        }
+
         let firstHop = resolvedJumps.first ?? resolvedPrimary
         let socketFD = try connectTCP(host: firstHop.host, port: firstHop.port)
 

TablePro/Models/Connection/SSHTypes.swift

@@ -94,8 +94,9 @@ struct SSHJumpHost: Codable, Hashable, Identifiable {
     var privateKeyPath: String = ""
 
     var isValid: Bool {
-        !host.isEmpty && !username.isEmpty &&
-        (authMethod == .sshAgent || !privateKeyPath.isEmpty)
+        // Username and port may be empty: the runtime resolver fills them
+        // from ~/.ssh/config (User, Port directives) when the alias matches.
+        !host.isEmpty && (authMethod == .sshAgent || !privateKeyPath.isEmpty)
     }
 
     var proxyJumpString: String {
@@ -118,24 +119,12 @@ struct SSHConfiguration: Codable, Hashable {
     var totpDigits: Int = 6
     var totpPeriod: Int = 30
 
-    /// Check if SSH configuration is complete enough for connection
+    /// Username may be empty: the runtime resolver supplies `User` from
+    /// `~/.ssh/config` when the host is an alias.
     var isValid: Bool {
-        guard enabled else { return true }  // Not enabled = valid (skip SSH)
-        guard !host.isEmpty, !username.isEmpty else { return false }
-
-        let authValid: Bool
-        switch authMethod {
-        case .password:
-            authValid = true
-        case .privateKey:
-            authValid = true
-        case .sshAgent:
-            authValid = true
-        case .keyboardInteractive:
-            authValid = true
-        }
-
-        return authValid && jumpHosts.allSatisfy(\.isValid)
+        guard enabled else { return true }
+        guard !host.isEmpty else { return false }
+        return jumpHosts.allSatisfy(\.isValid)
     }
 }
 

TablePro/Views/Connection/ConnectionFormView+Helpers.swift

@@ -57,7 +57,9 @@ extension ConnectionFormView {
         if sshState.enabled && sshState.profileId == nil {
             let sshPortValid = sshState.port.isEmpty
                 || (Int(sshState.port).map { (1...65_535).contains($0) } ?? false)
-            let sshValid = !sshState.host.isEmpty && !sshState.username.isEmpty && sshPortValid
+            // Username may be empty: the runtime resolver fills it from
+            // `~/.ssh/config` if the host is an alias with a User directive.
+            let sshValid = !sshState.host.isEmpty && sshPortValid
             let authValid =
                 sshState.authMethod == .password || sshState.authMethod == .sshAgent
                 || sshState.authMethod == .keyboardInteractive || sshState.authMethod == .privateKey

TableProTests/Core/SSH/SSHConfigurationTests.swift

@@ -68,13 +68,13 @@ struct SSHConfigurationTests {
         #expect(config.isValid == false)
     }
 
-    @Test("Missing username makes config invalid")
-    func testMissingUsernameInvalid() {
+    @Test("Empty username is allowed (runtime resolver fills it from ssh config)")
+    func testEmptyUsernameAllowed() {
         let config = SSHConfiguration(
             enabled: true, host: "example.com", username: "",
             authMethod: .sshAgent
         )
-        #expect(config.isValid == false)
+        #expect(config.isValid == true)
     }
 
     @Test("Agent socket path defaults to empty string")

TableProTests/Core/SSH/SSHJumpHostTests.swift

@@ -53,10 +53,10 @@ struct SSHJumpHostTests {
         #expect(jumpHost.isValid == false)
     }
 
-    @Test("isValid fails with empty username")
-    func testIsInvalidWithEmptyUsername() {
+    @Test("isValid allows empty username (filled by runtime resolver)")
+    func testValidWithEmptyUsername() {
         let jumpHost = SSHJumpHost(host: "bastion.example.com", username: "")
-        #expect(jumpHost.isValid == false)
+        #expect(jumpHost.isValid == true)
     }
 
     @Test("Codable round-trip preserves all fields")